import { buildPluginApi } from "../../src/plugins/api-builder.js";

import type { PluginRuntime } from "../../src/plugins/runtime/types.js";

import { registerSingleProviderPlugin } from "../../test/helpers/plugins/plugin-registration.js";

import { resetBedrockDiscoveryCacheForTest } from "./discovery.js";

import amazonBedrockPlugin from "./index.js";

import { resetBedrockAppProfileCacheEligibilityForTest } from "./register.sync.runtime.js";

type BedrockClientResult =

| {

}

| Error;

const inferenceProfileResults: BedrockClientResult[] = [];

const foundationModelResults: BedrockClientResult[] = [];

const inferenceProfileListResults: BedrockClientResult[] = [];

const inferenceProfileGetResults: BedrockClientResult[] = [];

const bedrockClientConfigs: Array<Record<string, unknown>> = [];

const sendGetInferenceProfile = vi.fn(async () => {

const next = inferenceProfileResults.shift();

const sendBedrockCommand = vi.fn(async (command: unknown) => {

const commandName = command?.constructor?.name;

const queue =

commandName === "ListFoundationModelsCommand"

? foundationModelResults

: commandName === "ListInferenceProfilesCommand"

? inferenceProfileListResults

: inferenceProfileGetResults;

const next = queue.shift();

if (next instanceof Error) {

throw next;

}

return next ?? { models: [] };

if (next) {

return next;

}

if (commandName === "ListFoundationModelsCommand") {

return {

modelSummaries: [

{

modelId: NON_ANTHROPIC_MODEL,

modelName: "Nova Micro",

providerName: "Amazon",

inputModalities: ["TEXT"],

outputModalities: ["TEXT"],

responseStreamingSupported: true,

modelLifecycle: { status: "ACTIVE" },

},

],

};

}

if (commandName === "ListInferenceProfilesCommand") {

return { inferenceProfileSummaries: [] };

}

return { models: [] };

});

vi.mock("@aws-sdk/client-bedrock", () => {

bedrockClientConfigs.push(config);

}

send = sendGetInferenceProfile;

send = sendBedrockCommand;

}

return {

return result;

}

async function runCatalog(

provider: RegisteredProviderPlugin,

config: OpenClawConfig,

env: NodeJS.ProcessEnv = {} as NodeJS.ProcessEnv,

) {

return provider.catalog?.run({

config,

env,

} as never);

}

function runtimePluginConfig(config?: Record<string, unknown>): OpenClawConfig {

return {

plugins: {

describe("amazon-bedrock provider plugin", () => {

beforeEach(() => {

inferenceProfileResults.length = 0;

foundationModelResults.length = 0;

inferenceProfileListResults.length = 0;

inferenceProfileGetResults.length = 0;

bedrockClientConfigs.length = 0;

sendGetInferenceProfile.mockClear();

sendBedrockCommand.mockClear();

resetBedrockDiscoveryCacheForTest();

resetBedrockAppProfileCacheEligibilityForTest();

});

it("marks Claude 4.6 Bedrock models as adaptive by default", async () => {

});

});

describe("discovery config", () => {

it("uses live plugin config to re-enable discovery after startup disable", async () => {

inferenceProfileResults.push(

{

modelSummaries: [

{

modelId: NON_ANTHROPIC_MODEL,

modelName: "Nova Micro",

providerName: "Amazon",

inputModalities: ["TEXT"],

outputModalities: ["TEXT"],

responseStreamingSupported: true,

modelLifecycle: { status: "ACTIVE" },

},

],

},

{

inferenceProfileSummaries: [],

},

);

const provider = await registerWithConfig({

discovery: {

enabled: false,

},

});

const catalog = await runCatalog(

provider,

runtimePluginConfig({

discovery: {

enabled: true,

region: "us-east-1",

},

}),

);

expect(catalog).toMatchObject({

provider: {

baseUrl: "https://bedrock-runtime.us-east-1.amazonaws.com",

api: "bedrock-converse-stream",

},

});

});

});

describe("application inference profile cache point injection", () => {

/**

* Invoke wrapStreamFn with a payload containing system/messages, then

it("injects cache points for opaque application inference profile ARNs after profile lookup", async () => {

const modelId =

"arn:aws:bedrock:us-east-1:123456789012:application-inference-profile/z27qyso459da";

inferenceProfileResults.push({

inferenceProfileGetResults.push({

models: [

{

modelArn:

const system = payload.system as Array<Record<string, unknown>>;

expect(system[1]).toEqual({ cachePoint: { type: "default" } });

expect(sendGetInferenceProfile).toHaveBeenCalledTimes(1);

expect(sendBedrockCommand).toHaveBeenCalledTimes(1);

expect(bedrockClientConfigs).toEqual([{ region: "us-east-1" }]);

});

it("does not inject cache points when any resolved profile target is not cacheable", async () => {

const modelId =

"arn:aws:bedrock:us-east-1:123456789012:application-inference-profile/z27qyso459db";

inferenceProfileResults.push({

inferenceProfileGetResults.push({

models: [

{

modelArn:

it("retries opaque profile lookup after a transient failure instead of caching the fallback", async () => {

const modelId =

"arn:aws:bedrock:us-east-1:123456789012:application-inference-profile/z27qyso459dc";

inferenceProfileResults.push(new Error("throttled"), {

inferenceProfileGetResults.push(new Error("throttled"), {

models: [

{

modelArn:

{ text: "You are helpful." },

{ cachePoint: { type: "default" } },

]);

expect(sendGetInferenceProfile).toHaveBeenCalledTimes(2);

expect(sendBedrockCommand).toHaveBeenCalledTimes(2);

});

});

});