@warlock.js/ai 4.1.1

package/esm/mock/index.d.mts

@@ -0,0 +1,4 @@
+import { MockModelResponse, MockSDKConfig } from "./mock-config.type.mjs";
+import { mockAgent } from "./mock-agent.mjs";
+import { MockModel } from "./mock-model.mjs";
+import { MockSDK } from "./mock-sdk.mjs";

package/esm/mock/index.mjs

@@ -0,0 +1,5 @@
+import { MockModel } from "./mock-model.mjs";
+import { MockSDK } from "./mock-sdk.mjs";
+import { mockAgent } from "./mock-agent.mjs";
+
+export {  };

package/esm/mock/mock-agent.d.mts

@@ -0,0 +1,41 @@
+import { AgentContract } from "../contracts/agent/agent.contract.mjs";
+import { ToolContract } from "../tool/tool.mjs";
+import { MockModelResponse } from "./mock-config.type.mjs";
+
+//#region ../../@warlock.js/ai/src/mock/mock-agent.d.ts
+/**
+ * Test helper that wires `MockSDK` → mock model → `agent()` in one call.
+ *
+ * Replaces the 4-line ritual specs typically write:
+ * ```ts
+ * const mock = MockSDK({ responses: [...] });
+ * const myAgent = agent({ name: "x", model: mock.model({ name: "m" }) });
+ * ```
+ *
+ * Defaults to a single empty `"stop"` response — enough to exercise an
+ * agent that doesn't need a scripted reply (composition wiring,
+ * anonymous-name tests, etc.). Pass `responses` to script outputs.
+ *
+ * `name` is optional — when omitted the resulting agent runs through
+ * the normal anonymous-name fingerprint
+ * (`anon_<provider>_<model>[_<tool1>+<tool2>...]`), which is the
+ * default for `agent({ model })`.
+ *
+ * @example
+ * const a = mockAgent({ name: "writer", responses: [{ content: "hi", finishReason: "stop" }] });
+ * const result = await a.execute("anything");
+ */
+declare function mockAgent<TOutput = unknown>(options?: {
+  name?: string;
+  responses?: MockModelResponse[];
+  tools?: ToolContract<unknown, unknown>[];
+  /**
+   * Override the model name reported by the mock model. Defaults to
+   * `"mock-model"` (the MockSDK default). Useful when a test needs
+   * deterministic provider/model fingerprinting.
+   */
+  modelName?: string;
+}): AgentContract<TOutput>;
+//#endregion
+export { mockAgent };
+//# sourceMappingURL=mock-agent.d.mts.map

package/esm/mock/mock-agent.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-agent.d.mts","names":[],"sources":["../../../../../../@warlock.js/ai/src/mock/mock-agent.ts"],"mappings":";;;;;;;AA6BA;;;;;;;;;;;;;;;;;;;;iBAAgB,SAAA,mBAAA,CACd,OAAA;EACE,IAAA;EACA,SAAA,GAAY,iBAAA;EACZ,KAAA,GAAQ,YAAA;;;;;;EAMR,SAAA;AAAA,IAED,aAAA,CAAc,OAAA"}

package/esm/mock/mock-agent.mjs

@@ -0,0 +1,39 @@
+import { agent } from "../agent/agent.mjs";
+import { MockSDK } from "./mock-sdk.mjs";
+
+//#region ../../@warlock.js/ai/src/mock/mock-agent.ts
+/**
+* Test helper that wires `MockSDK` → mock model → `agent()` in one call.
+*
+* Replaces the 4-line ritual specs typically write:
+* ```ts
+* const mock = MockSDK({ responses: [...] });
+* const myAgent = agent({ name: "x", model: mock.model({ name: "m" }) });
+* ```
+*
+* Defaults to a single empty `"stop"` response — enough to exercise an
+* agent that doesn't need a scripted reply (composition wiring,
+* anonymous-name tests, etc.). Pass `responses` to script outputs.
+*
+* `name` is optional — when omitted the resulting agent runs through
+* the normal anonymous-name fingerprint
+* (`anon_<provider>_<model>[_<tool1>+<tool2>...]`), which is the
+* default for `agent({ model })`.
+*
+* @example
+* const a = mockAgent({ name: "writer", responses: [{ content: "hi", finishReason: "stop" }] });
+* const result = await a.execute("anything");
+*/
+function mockAgent(options = {}) {
+	const config = { model: MockSDK({ responses: options.responses ?? [{
+		content: "",
+		finishReason: "stop"
+	}] }).model({ name: options.modelName ?? "mock-model" }) };
+	if (options.name !== void 0) config.name = options.name;
+	if (options.tools !== void 0) config.tools = options.tools;
+	return agent(config);
+}
+
+//#endregion
+export { mockAgent };
+//# sourceMappingURL=mock-agent.mjs.map

package/esm/mock/mock-agent.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-agent.mjs","names":[],"sources":["../../../../../../@warlock.js/ai/src/mock/mock-agent.ts"],"sourcesContent":["import { agent } from \"../agent/agent\";\nimport type { AgentConfig } from \"../agent/agent-config.type\";\nimport type { AgentContract } from \"../contracts/agent/agent.contract\";\nimport type { ToolContract } from \"../tool/tool\";\nimport type { MockModelResponse } from \"./mock-config.type\";\nimport { MockSDK } from \"./mock-sdk\";\n\n/**\n * Test helper that wires `MockSDK` → mock model → `agent()` in one call.\n *\n * Replaces the 4-line ritual specs typically write:\n * ```ts\n * const mock = MockSDK({ responses: [...] });\n * const myAgent = agent({ name: \"x\", model: mock.model({ name: \"m\" }) });\n * ```\n *\n * Defaults to a single empty `\"stop\"` response — enough to exercise an\n * agent that doesn't need a scripted reply (composition wiring,\n * anonymous-name tests, etc.). Pass `responses` to script outputs.\n *\n * `name` is optional — when omitted the resulting agent runs through\n * the normal anonymous-name fingerprint\n * (`anon_<provider>_<model>[_<tool1>+<tool2>...]`), which is the\n * default for `agent({ model })`.\n *\n * @example\n * const a = mockAgent({ name: \"writer\", responses: [{ content: \"hi\", finishReason: \"stop\" }] });\n * const result = await a.execute(\"anything\");\n */\nexport function mockAgent<TOutput = unknown>(\n  options: {\n    name?: string;\n    responses?: MockModelResponse[];\n    tools?: ToolContract<unknown, unknown>[];\n    /**\n     * Override the model name reported by the mock model. Defaults to\n     * `\"mock-model\"` (the MockSDK default). Useful when a test needs\n     * deterministic provider/model fingerprinting.\n     */\n    modelName?: string;\n  } = {},\n): AgentContract<TOutput> {\n  const responses = options.responses ?? [{ content: \"\", finishReason: \"stop\" as const }];\n  const sdk = MockSDK({ responses });\n  const model = sdk.model({ name: options.modelName ?? \"mock-model\" });\n\n  const config: AgentConfig<TOutput> = { model };\n\n  if (options.name !== undefined) {\n    config.name = options.name;\n  }\n\n  if (options.tools !== undefined) {\n    config.tools = options.tools;\n  }\n\n  return agent<TOutput>(config);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,SAAgB,UACd,UAUI,CAAC,GACmB;CAKxB,MAAM,SAA+B,EAAE,OAH3B,QAAQ,EAAE,WADJ,QAAQ,aAAa,CAAC;EAAE,SAAS;EAAI,cAAc;CAAgB,CAAC,EACtD,CAChB,EAAE,MAAM,EAAE,MAAM,QAAQ,aAAa,aAAa,CAEvB,EAAE;CAE7C,IAAI,QAAQ,SAAS,QACnB,OAAO,OAAO,QAAQ;CAGxB,IAAI,QAAQ,UAAU,QACpB,OAAO,QAAQ,QAAQ;CAGzB,OAAO,MAAe,MAAM;AAC9B"}

package/esm/mock/mock-config.type.d.mts

@@ -0,0 +1,31 @@
+import { ModelToolCallRequest } from "../contracts/model-tool-call-request.type.mjs";
+import { Usage } from "../contracts/result/usage.type.mjs";
+import { FinishReason } from "../contracts/finish-reason.type.mjs";
+import { ModelCapabilities } from "../contracts/model.contract.mjs";
+//#region ../../@warlock.js/ai/src/mock/mock-config.type.d.ts
+/**
+ * Configuration for a single mock model response.
+ * Responses are consumed in order — last one repeats if list is exhausted.
+ */
+type MockModelResponse = {
+  content: string;
+  finishReason?: FinishReason;
+  usage?: Usage;
+  toolCalls?: ModelToolCallRequest[]; /** Simulate a delay in ms before resolving */
+  delay?: number; /** Throw this error instead of returning a response */
+  error?: Error;
+};
+type MockSDKConfig = {
+  /** Responses to return in sequence. Last one repeats when exhausted. */responses?: MockModelResponse[]; /** Default model name reported by mock models */
+  defaultModelName?: string;
+  /**
+   * Capability flags reported by every model this mock SDK creates.
+   * Tests use this to exercise capability-gated agent behavior (e.g.
+   * vision attachments, native structured output) without standing up
+   * a real provider.
+   */
+  capabilities?: ModelCapabilities;
+};
+//#endregion
+export { MockModelResponse, MockSDKConfig };
+//# sourceMappingURL=mock-config.type.d.mts.map

package/esm/mock/mock-config.type.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-config.type.d.mts","names":[],"sources":["../../../../../../@warlock.js/ai/src/mock/mock-config.type.ts"],"mappings":";;;;;;;;AASA;KAAY,iBAAA;EACV,OAAA;EACA,YAAA,GAAe,YAAA;EACf,KAAA,GAAQ,KAAA;EACR,SAAA,GAAY,oBAAA,IAIJ;EAFR,KAAA,WAEa;EAAb,KAAA,GAAQ,KAAA;AAAA;AAAA,KAGE,aAAA;EARV,wEAUA,SAAA,GAAY,iBAAA,IATZ;EAWA,gBAAA;EATA;;;;AAEa;AAGf;EAWE,YAAA,GAAe,iBAAiB;AAAA"}

package/esm/mock/mock-model.d.mts

@@ -0,0 +1,94 @@
+import { Message } from "../contracts/conversation-message.type.mjs";
+import { ModelCallOptions, ModelCapabilities, ModelContract, ModelResponse, ModelStreamChunk } from "../contracts/model.contract.mjs";
+import { MockModelResponse } from "./mock-config.type.mjs";
+
+//#region ../../@warlock.js/ai/src/mock/mock-model.d.ts
+type RecordedCall = {
+  messages: Message[];
+  options?: ModelCallOptions;
+};
+/**
+ * Deterministic in-memory `ModelContract` implementation for tests.
+ *
+ * **Role.** Stands in for a real provider model so agent/workflow/supervisor
+ * tests can assert behavior without hitting the network, spending tokens, or
+ * depending on non-deterministic LLM output.
+ *
+ * **Responsibility.**
+ * - Owns: a scripted queue of `MockModelResponse` entries, a call-history
+ *   log for assertions, and the index pointer that advances through the
+ *   queue on each `complete()` / `stream()` call.
+ * - Does NOT own: any real inference, tokenization, or network I/O — when
+ *   the queue is exhausted, the final entry is reused so tests never crash
+ *   on accidental over-consumption.
+ *
+ * Every AI-related test in this repo uses `MockSDK` / `MockModel` — real
+ * provider APIs are never hit from the test suite (see §6 of code-style.md).
+ *
+ * @example
+ * const model = new MockModel("mock-gpt", [
+ *   { content: "Hello!", finishReason: "stop" },
+ *   { content: "Second turn.", finishReason: "stop" },
+ * ]);
+ *
+ * const first = await model.complete([{ role: "user", content: "hi" }]);
+ * expect(first.content).toBe("Hello!");
+ * expect(model.callCount).toBe(1);
+ */
+declare class MockModel implements ModelContract {
+  readonly name: string;
+  private readonly responses;
+  readonly provider = "mock";
+  readonly capabilities?: ModelCapabilities;
+  private responseIndex;
+  private calls;
+  constructor(name: string, responses: MockModelResponse[], capabilities?: ModelCapabilities);
+  /**
+   * Full history of calls made to this model. Each entry is the exact
+   * `{ messages, options }` pair that was passed — useful for asserting
+   * that an agent built the right prompt or forwarded the right tool list.
+   */
+  get callHistory(): RecordedCall[];
+  /**
+   * Number of times `complete()` or `stream()` has been invoked. Convenient
+   * shorthand for `callHistory.length` in assertions.
+   */
+  get callCount(): number;
+  /**
+   * Advance the scripted response queue by one and return the entry at the
+   * current pointer. If the queue is exhausted, the final scripted entry is
+   * returned repeatedly so over-consumption in tests produces predictable
+   * output instead of `undefined`.
+   */
+  private nextResponse;
+  /**
+   * Convert a scripted `MockModelResponse` into a full `ModelResponse` with
+   * synthesized usage numbers when the script didn't supply them. Input
+   * usage is a fixed estimate; output usage is derived from content length.
+   */
+  private buildResponse;
+  /**
+   * Record the call, optionally delay (to simulate latency), and either
+   * throw the scripted error or return the scripted response. Mirrors the
+   * real provider's `complete()` contract so agents cannot tell the
+   * difference at runtime.
+   */
+  complete(messages: Message[], options?: ModelCallOptions): Promise<ModelResponse>;
+  /**
+   * Record the call, optionally delay, then emit the scripted response as a
+   * sequence of stream chunks: content split word-by-word as `delta`
+   * chunks, each scripted tool call as a `tool-call` chunk, and finally a
+   * `done` chunk with finish reason + usage. Throws eagerly if the scripted
+   * entry carries an `error`.
+   */
+  stream(messages: Message[], options?: ModelCallOptions): AsyncIterable<ModelStreamChunk>;
+  /**
+   * Reset call history and response pointer back to their initial state.
+   * Intended for test-suite `beforeEach` hooks so a single `MockModel`
+   * instance can be reused across cases without cross-test leakage.
+   */
+  reset(): void;
+}
+//#endregion
+export { MockModel };
+//# sourceMappingURL=mock-model.d.mts.map

package/esm/mock/mock-model.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-model.d.mts","names":[],"sources":["../../../../../../@warlock.js/ai/src/mock/mock-model.ts"],"mappings":";;;;;KAUK,YAAA;EACH,QAAA,EAAU,OAAA;EACV,OAAA,GAAU,gBAAgB;AAAA;;;;;;;;AAAA;AA+B5B;;;;;;;;;;;;;;;;;;;;cAAa,SAAA,YAAqB,aAAA;EAAA,SAQd,IAAA;EAAA,iBACC,SAAA;EAAA,SARH,QAAA;EAAA,SACA,YAAA,GAAe,iBAAA;EAAA,QAEvB,aAAA;EAAA,QACA,KAAA;cAGU,IAAA,UACC,SAAA,EAAW,iBAAA,IAC5B,YAAA,GAAe,iBAAA;EADa;;;;;EAAA,IAWnB,WAAA,CAAA,GAAe,YAAA;EAQf;;;;EAAA,IAAA,SAAA,CAAA;EA8CW;;;;;;EAAA,QApCd,YAAA;EA4DN;;;;;EAAA,QA/CM,aAAA;EA6FI;AAAA;;;;;EAtEC,QAAA,CAAS,QAAA,EAAU,OAAA,IAAW,OAAA,GAAU,gBAAA,GAAmB,OAAA,CAAQ,aAAA;;;;;;;;EAuBlE,MAAA,CACZ,QAAA,EAAU,OAAA,IACV,OAAA,GAAU,gBAAA,GACT,aAAA,CAAc,gBAAA;;;;;;EA4CV,KAAA,CAAA;AAAA"}

package/esm/mock/mock-model.mjs

@@ -0,0 +1,150 @@
+//#region ../../@warlock.js/ai/src/mock/mock-model.ts
+/**
+* Deterministic in-memory `ModelContract` implementation for tests.
+*
+* **Role.** Stands in for a real provider model so agent/workflow/supervisor
+* tests can assert behavior without hitting the network, spending tokens, or
+* depending on non-deterministic LLM output.
+*
+* **Responsibility.**
+* - Owns: a scripted queue of `MockModelResponse` entries, a call-history
+*   log for assertions, and the index pointer that advances through the
+*   queue on each `complete()` / `stream()` call.
+* - Does NOT own: any real inference, tokenization, or network I/O — when
+*   the queue is exhausted, the final entry is reused so tests never crash
+*   on accidental over-consumption.
+*
+* Every AI-related test in this repo uses `MockSDK` / `MockModel` — real
+* provider APIs are never hit from the test suite (see §6 of code-style.md).
+*
+* @example
+* const model = new MockModel("mock-gpt", [
+*   { content: "Hello!", finishReason: "stop" },
+*   { content: "Second turn.", finishReason: "stop" },
+* ]);
+*
+* const first = await model.complete([{ role: "user", content: "hi" }]);
+* expect(first.content).toBe("Hello!");
+* expect(model.callCount).toBe(1);
+*/
+var MockModel = class {
+	constructor(name, responses, capabilities) {
+		this.name = name;
+		this.responses = responses;
+		this.provider = "mock";
+		this.responseIndex = 0;
+		this.calls = [];
+		this.capabilities = capabilities;
+	}
+	/**
+	* Full history of calls made to this model. Each entry is the exact
+	* `{ messages, options }` pair that was passed — useful for asserting
+	* that an agent built the right prompt or forwarded the right tool list.
+	*/
+	get callHistory() {
+		return this.calls;
+	}
+	/**
+	* Number of times `complete()` or `stream()` has been invoked. Convenient
+	* shorthand for `callHistory.length` in assertions.
+	*/
+	get callCount() {
+		return this.calls.length;
+	}
+	/**
+	* Advance the scripted response queue by one and return the entry at the
+	* current pointer. If the queue is exhausted, the final scripted entry is
+	* returned repeatedly so over-consumption in tests produces predictable
+	* output instead of `undefined`.
+	*/
+	nextResponse() {
+		const response = this.responses[Math.min(this.responseIndex, this.responses.length - 1)];
+		this.responseIndex++;
+		return response ?? {
+			content: "Mock response",
+			finishReason: "stop"
+		};
+	}
+	/**
+	* Convert a scripted `MockModelResponse` into a full `ModelResponse` with
+	* synthesized usage numbers when the script didn't supply them. Input
+	* usage is a fixed estimate; output usage is derived from content length.
+	*/
+	buildResponse(mock) {
+		const estimatedInput = 10;
+		const estimatedOutput = Math.ceil(mock.content.length / 4);
+		return {
+			content: mock.content,
+			finishReason: mock.finishReason ?? "stop",
+			usage: {
+				input: mock.usage?.input ?? estimatedInput,
+				output: mock.usage?.output ?? estimatedOutput,
+				total: (mock.usage?.input ?? estimatedInput) + (mock.usage?.output ?? estimatedOutput),
+				...mock.usage?.cachedTokens !== void 0 ? { cachedTokens: mock.usage.cachedTokens } : {}
+			},
+			toolCalls: mock.toolCalls
+		};
+	}
+	/**
+	* Record the call, optionally delay (to simulate latency), and either
+	* throw the scripted error or return the scripted response. Mirrors the
+	* real provider's `complete()` contract so agents cannot tell the
+	* difference at runtime.
+	*/
+	async complete(messages, options) {
+		this.calls.push({
+			messages,
+			options
+		});
+		const mock = this.nextResponse();
+		if (mock.delay) await new Promise((resolve) => setTimeout(resolve, mock.delay));
+		if (mock.error) throw mock.error;
+		return this.buildResponse(mock);
+	}
+	/**
+	* Record the call, optionally delay, then emit the scripted response as a
+	* sequence of stream chunks: content split word-by-word as `delta`
+	* chunks, each scripted tool call as a `tool-call` chunk, and finally a
+	* `done` chunk with finish reason + usage. Throws eagerly if the scripted
+	* entry carries an `error`.
+	*/
+	async *stream(messages, options) {
+		this.calls.push({
+			messages,
+			options
+		});
+		const mock = this.nextResponse();
+		if (mock.delay) await new Promise((resolve) => setTimeout(resolve, mock.delay));
+		if (mock.error) throw mock.error;
+		const words = mock.content.split(" ");
+		for (const word of words) yield {
+			type: "delta",
+			content: word + " "
+		};
+		if (mock.toolCalls) for (const toolCall of mock.toolCalls) yield {
+			type: "tool-call",
+			id: toolCall.id,
+			name: toolCall.name,
+			input: toolCall.input
+		};
+		const response = this.buildResponse(mock);
+		yield {
+			type: "done",
+			finishReason: response.finishReason,
+			usage: response.usage
+		};
+	}
+	/**
+	* Reset call history and response pointer back to their initial state.
+	* Intended for test-suite `beforeEach` hooks so a single `MockModel`
+	* instance can be reused across cases without cross-test leakage.
+	*/
+	reset() {
+		this.calls = [];
+		this.responseIndex = 0;
+	}
+};
+
+//#endregion
+export { MockModel };
+//# sourceMappingURL=mock-model.mjs.map

package/esm/mock/mock-model.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-model.mjs","names":[],"sources":["../../../../../../@warlock.js/ai/src/mock/mock-model.ts"],"sourcesContent":["import type { Message } from \"../contracts/conversation-message.type\";\nimport type {\n  ModelCallOptions,\n  ModelCapabilities,\n  ModelContract,\n  ModelResponse,\n  ModelStreamChunk,\n} from \"../contracts/model.contract\";\nimport type { MockModelResponse } from \"./mock-config.type\";\n\ntype RecordedCall = {\n  messages: Message[];\n  options?: ModelCallOptions;\n};\n\n/**\n * Deterministic in-memory `ModelContract` implementation for tests.\n *\n * **Role.** Stands in for a real provider model so agent/workflow/supervisor\n * tests can assert behavior without hitting the network, spending tokens, or\n * depending on non-deterministic LLM output.\n *\n * **Responsibility.**\n * - Owns: a scripted queue of `MockModelResponse` entries, a call-history\n *   log for assertions, and the index pointer that advances through the\n *   queue on each `complete()` / `stream()` call.\n * - Does NOT own: any real inference, tokenization, or network I/O — when\n *   the queue is exhausted, the final entry is reused so tests never crash\n *   on accidental over-consumption.\n *\n * Every AI-related test in this repo uses `MockSDK` / `MockModel` — real\n * provider APIs are never hit from the test suite (see §6 of code-style.md).\n *\n * @example\n * const model = new MockModel(\"mock-gpt\", [\n *   { content: \"Hello!\", finishReason: \"stop\" },\n *   { content: \"Second turn.\", finishReason: \"stop\" },\n * ]);\n *\n * const first = await model.complete([{ role: \"user\", content: \"hi\" }]);\n * expect(first.content).toBe(\"Hello!\");\n * expect(model.callCount).toBe(1);\n */\nexport class MockModel implements ModelContract {\n  public readonly provider = \"mock\";\n  public readonly capabilities?: ModelCapabilities;\n\n  private responseIndex = 0;\n  private calls: RecordedCall[] = [];\n\n  public constructor(\n    public readonly name: string,\n    private readonly responses: MockModelResponse[],\n    capabilities?: ModelCapabilities,\n  ) {\n    this.capabilities = capabilities;\n  }\n\n  /**\n   * Full history of calls made to this model. Each entry is the exact\n   * `{ messages, options }` pair that was passed — useful for asserting\n   * that an agent built the right prompt or forwarded the right tool list.\n   */\n  public get callHistory(): RecordedCall[] {\n    return this.calls;\n  }\n\n  /**\n   * Number of times `complete()` or `stream()` has been invoked. Convenient\n   * shorthand for `callHistory.length` in assertions.\n   */\n  public get callCount(): number {\n    return this.calls.length;\n  }\n\n  /**\n   * Advance the scripted response queue by one and return the entry at the\n   * current pointer. If the queue is exhausted, the final scripted entry is\n   * returned repeatedly so over-consumption in tests produces predictable\n   * output instead of `undefined`.\n   */\n  private nextResponse(): MockModelResponse {\n    const response = this.responses[Math.min(this.responseIndex, this.responses.length - 1)];\n\n    this.responseIndex++;\n\n    return response ?? { content: \"Mock response\", finishReason: \"stop\" };\n  }\n\n  /**\n   * Convert a scripted `MockModelResponse` into a full `ModelResponse` with\n   * synthesized usage numbers when the script didn't supply them. Input\n   * usage is a fixed estimate; output usage is derived from content length.\n   */\n  private buildResponse(mock: MockModelResponse): ModelResponse {\n    const estimatedInput = 10;\n    const estimatedOutput = Math.ceil(mock.content.length / 4);\n\n    return {\n      content: mock.content,\n      finishReason: mock.finishReason ?? \"stop\",\n      usage: {\n        input: mock.usage?.input ?? estimatedInput,\n        output: mock.usage?.output ?? estimatedOutput,\n        total: (mock.usage?.input ?? estimatedInput) + (mock.usage?.output ?? estimatedOutput),\n        ...(mock.usage?.cachedTokens !== undefined ? { cachedTokens: mock.usage.cachedTokens } : {}),\n      },\n      toolCalls: mock.toolCalls,\n    };\n  }\n\n  /**\n   * Record the call, optionally delay (to simulate latency), and either\n   * throw the scripted error or return the scripted response. Mirrors the\n   * real provider's `complete()` contract so agents cannot tell the\n   * difference at runtime.\n   */\n  public async complete(messages: Message[], options?: ModelCallOptions): Promise<ModelResponse> {\n    this.calls.push({ messages, options });\n\n    const mock = this.nextResponse();\n\n    if (mock.delay) {\n      await new Promise((resolve) => setTimeout(resolve, mock.delay));\n    }\n\n    if (mock.error) {\n      throw mock.error;\n    }\n\n    return this.buildResponse(mock);\n  }\n\n  /**\n   * Record the call, optionally delay, then emit the scripted response as a\n   * sequence of stream chunks: content split word-by-word as `delta`\n   * chunks, each scripted tool call as a `tool-call` chunk, and finally a\n   * `done` chunk with finish reason + usage. Throws eagerly if the scripted\n   * entry carries an `error`.\n   */\n  public async *stream(\n    messages: Message[],\n    options?: ModelCallOptions,\n  ): AsyncIterable<ModelStreamChunk> {\n    this.calls.push({ messages, options });\n\n    const mock = this.nextResponse();\n\n    if (mock.delay) {\n      await new Promise((resolve) => setTimeout(resolve, mock.delay));\n    }\n\n    if (mock.error) {\n      throw mock.error;\n    }\n\n    const words = mock.content.split(\" \");\n\n    for (const word of words) {\n      yield { type: \"delta\", content: word + \" \" };\n    }\n\n    if (mock.toolCalls) {\n      for (const toolCall of mock.toolCalls) {\n        yield {\n          type: \"tool-call\",\n          id: toolCall.id,\n          name: toolCall.name,\n          input: toolCall.input,\n        };\n      }\n    }\n\n    const response = this.buildResponse(mock);\n\n    yield {\n      type: \"done\",\n      finishReason: response.finishReason,\n      usage: response.usage,\n    };\n  }\n\n  /**\n   * Reset call history and response pointer back to their initial state.\n   * Intended for test-suite `beforeEach` hooks so a single `MockModel`\n   * instance can be reused across cases without cross-test leakage.\n   */\n  public reset(): void {\n    this.calls = [];\n    this.responseIndex = 0;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CA,IAAa,YAAb,MAAgD;CAO9C,AAAO,YACL,AAAgB,MAChB,AAAiB,WACjB,cACA;EAHgB;EACC;kBARQ;uBAGH;eACQ,CAAC;EAO/B,KAAK,eAAe;CACtB;;;;;;CAOA,IAAW,cAA8B;EACvC,OAAO,KAAK;CACd;;;;;CAMA,IAAW,YAAoB;EAC7B,OAAO,KAAK,MAAM;CACpB;;;;;;;CAQA,AAAQ,eAAkC;EACxC,MAAM,WAAW,KAAK,UAAU,KAAK,IAAI,KAAK,eAAe,KAAK,UAAU,SAAS,CAAC;EAEtF,KAAK;EAEL,OAAO,YAAY;GAAE,SAAS;GAAiB,cAAc;EAAO;CACtE;;;;;;CAOA,AAAQ,cAAc,MAAwC;EAC5D,MAAM,iBAAiB;EACvB,MAAM,kBAAkB,KAAK,KAAK,KAAK,QAAQ,SAAS,CAAC;EAEzD,OAAO;GACL,SAAS,KAAK;GACd,cAAc,KAAK,gBAAgB;GACnC,OAAO;IACL,OAAO,KAAK,OAAO,SAAS;IAC5B,QAAQ,KAAK,OAAO,UAAU;IAC9B,QAAQ,KAAK,OAAO,SAAS,mBAAmB,KAAK,OAAO,UAAU;IACtE,GAAI,KAAK,OAAO,iBAAiB,SAAY,EAAE,cAAc,KAAK,MAAM,aAAa,IAAI,CAAC;GAC5F;GACA,WAAW,KAAK;EAClB;CACF;;;;;;;CAQA,MAAa,SAAS,UAAqB,SAAoD;EAC7F,KAAK,MAAM,KAAK;GAAE;GAAU;EAAQ,CAAC;EAErC,MAAM,OAAO,KAAK,aAAa;EAE/B,IAAI,KAAK,OACP,MAAM,IAAI,SAAS,YAAY,WAAW,SAAS,KAAK,KAAK,CAAC;EAGhE,IAAI,KAAK,OACP,MAAM,KAAK;EAGb,OAAO,KAAK,cAAc,IAAI;CAChC;;;;;;;;CASA,OAAc,OACZ,UACA,SACiC;EACjC,KAAK,MAAM,KAAK;GAAE;GAAU;EAAQ,CAAC;EAErC,MAAM,OAAO,KAAK,aAAa;EAE/B,IAAI,KAAK,OACP,MAAM,IAAI,SAAS,YAAY,WAAW,SAAS,KAAK,KAAK,CAAC;EAGhE,IAAI,KAAK,OACP,MAAM,KAAK;EAGb,MAAM,QAAQ,KAAK,QAAQ,MAAM,GAAG;EAEpC,KAAK,MAAM,QAAQ,OACjB,MAAM;GAAE,MAAM;GAAS,SAAS,OAAO;EAAI;EAG7C,IAAI,KAAK,WACP,KAAK,MAAM,YAAY,KAAK,WAC1B,MAAM;GACJ,MAAM;GACN,IAAI,SAAS;GACb,MAAM,SAAS;GACf,OAAO,SAAS;EAClB;EAIJ,MAAM,WAAW,KAAK,cAAc,IAAI;EAExC,MAAM;GACJ,MAAM;GACN,cAAc,SAAS;GACvB,OAAO,SAAS;EAClB;CACF;;;;;;CAOA,AAAO,QAAc;EACnB,KAAK,QAAQ,CAAC;EACd,KAAK,gBAAgB;CACvB;AACF"}

package/esm/mock/mock-sdk.d.mts

@@ -0,0 +1,25 @@
+import { SDKAdapterContract } from "../contracts/sdk-adapter.contract.mjs";
+import { MockSDKConfig } from "./mock-config.type.mjs";
+import { MockModel } from "./mock-model.mjs";
+
+//#region ../../@warlock.js/ai/src/mock/mock-sdk.d.ts
+/**
+ * Creates a mock SDK adapter for testing — no HTTP calls, fully configurable.
+ *
+ * @example
+ * const mock = MockSDK({
+ *   responses: [
+ *     { content: "Hello from mock!" },
+ *     { content: "Second response" },
+ *   ],
+ * });
+ * const model = mock.model({ name: "gpt-4o" });
+ * const result = await model.complete([{ role: "user", content: "Hi" }]);
+ * console.log(result.content); // "Hello from mock!"
+ */
+declare function MockSDK(config?: MockSDKConfig): SDKAdapterContract & {
+  /** All model instances created by this SDK — for inspecting calls in tests */models: MockModel[];
+};
+//#endregion
+export { MockSDK };
+//# sourceMappingURL=mock-sdk.d.mts.map

package/esm/mock/mock-sdk.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-sdk.d.mts","names":[],"sources":["../../../../../../@warlock.js/ai/src/mock/mock-sdk.ts"],"mappings":";;;;;;;AAsBA;;;;;;;;;;;;iBAAgB,OAAA,CAAQ,MAAA,GAAQ,aAAA,GAAqB,kBAAA;EAElC,8EAAjB,MAAA,EAAQ,SAAA;AAAA"}

package/esm/mock/mock-sdk.mjs

@@ -0,0 +1,37 @@
+import { approximateTokenCount } from "../utils/token-count.mjs";
+import { MockModel } from "./mock-model.mjs";
+
+//#region ../../@warlock.js/ai/src/mock/mock-sdk.ts
+/**
+* Creates a mock SDK adapter for testing — no HTTP calls, fully configurable.
+*
+* @example
+* const mock = MockSDK({
+*   responses: [
+*     { content: "Hello from mock!" },
+*     { content: "Second response" },
+*   ],
+* });
+* const model = mock.model({ name: "gpt-4o" });
+* const result = await model.complete([{ role: "user", content: "Hi" }]);
+* console.log(result.content); // "Hello from mock!"
+*/
+function MockSDK(config = {}) {
+	const models = [];
+	const responses = config.responses ?? [{ content: "Mock response" }];
+	return {
+		models,
+		model(modelConfig) {
+			const model = new MockModel(modelConfig.name ?? config.defaultModelName ?? "mock-model", responses, config.capabilities);
+			models.push(model);
+			return model;
+		},
+		async count(text, _model) {
+			return approximateTokenCount(text);
+		}
+	};
+}
+
+//#endregion
+export { MockSDK };
+//# sourceMappingURL=mock-sdk.mjs.map

package/esm/mock/mock-sdk.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-sdk.mjs","names":[],"sources":["../../../../../../@warlock.js/ai/src/mock/mock-sdk.ts"],"sourcesContent":["import type {\n  ModelConfig,\n  SDKAdapterContract,\n} from \"../contracts/sdk-adapter.contract\";\nimport { approximateTokenCount } from \"../utils/token-count\";\nimport type { MockSDKConfig } from \"./mock-config.type\";\nimport { MockModel } from \"./mock-model\";\n\n/**\n * Creates a mock SDK adapter for testing — no HTTP calls, fully configurable.\n *\n * @example\n * const mock = MockSDK({\n *   responses: [\n *     { content: \"Hello from mock!\" },\n *     { content: \"Second response\" },\n *   ],\n * });\n * const model = mock.model({ name: \"gpt-4o\" });\n * const result = await model.complete([{ role: \"user\", content: \"Hi\" }]);\n * console.log(result.content); // \"Hello from mock!\"\n */\nexport function MockSDK(config: MockSDKConfig = {}): SDKAdapterContract & {\n  /** All model instances created by this SDK — for inspecting calls in tests */\n  models: MockModel[];\n} {\n  const models: MockModel[] = [];\n  const responses = config.responses ?? [{ content: \"Mock response\" }];\n\n  return {\n    models,\n    model(modelConfig: ModelConfig) {\n      const model = new MockModel(\n        modelConfig.name ?? config.defaultModelName ?? \"mock-model\",\n        responses,\n        config.capabilities,\n      );\n      models.push(model);\n      return model;\n    },\n    async count(text: string, _model?: string): Promise<number> {\n      return approximateTokenCount(text);\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAsBA,SAAgB,QAAQ,SAAwB,CAAC,GAG/C;CACA,MAAM,SAAsB,CAAC;CAC7B,MAAM,YAAY,OAAO,aAAa,CAAC,EAAE,SAAS,gBAAgB,CAAC;CAEnE,OAAO;EACL;EACA,MAAM,aAA0B;GAC9B,MAAM,QAAQ,IAAI,UAChB,YAAY,QAAQ,OAAO,oBAAoB,cAC/C,WACA,OAAO,YACT;GACA,OAAO,KAAK,KAAK;GACjB,OAAO;EACT;EACA,MAAM,MAAM,MAAc,QAAkC;GAC1D,OAAO,sBAAsB,IAAI;EACnC;CACF;AACF"}

package/esm/supervisor/as-tool.d.mts

@@ -0,0 +1,45 @@
+import { ToolContract } from "../tool/tool.mjs";
+import { SupervisorAsToolOptions, SupervisorContract } from "../contracts/supervisor/supervisor.contract.mjs";
+
+//#region ../../@warlock.js/ai/src/supervisor/as-tool.d.ts
+/**
+ * Wrap a `SupervisorContract` as a `ToolContract` so an outer agent
+ * can invoke it from its tool-call loop. Mirrors
+ * `workflow.asTool()` / `agent.asTool()` — same composition pattern,
+ * same error-normalization behavior.
+ *
+ * Behavior:
+ * - The tool's `name` mirrors the supervisor's `name` unless the
+ *   caller overrides via `options.name`. Supervisors without a
+ *   meaningful name throw `SupervisorFailedError` — an outer agent
+ *   can't route to an anonymous tool.
+ * - Tool `input` is the supplied schema; the validated value is
+ *   coerced to a string (via `String()` for non-string values, or
+ *   `JSON.stringify()` for objects) before being forwarded to
+ *   `supervisor.execute(input)`. Consumers whose inputs need
+ *   richer shaping should pre-format the string themselves.
+ * - On `result.error`, the supervisor error is thrown so the tool
+ *   wrapper catches it and produces a `ToolExecutionError` with
+ *   `cause` set to the original typed supervisor error — the outer
+ *   agent sees one uniform error class regardless of which
+ *   primitive failed.
+ *
+ * **Usage caveat** (mirrors workflow-as-tool): nested usage is not
+ * rolled into the outer agent's `result.usage` today — the
+ * supervisor's tokens stay on the supervisor result. Sum manually
+ * if you need a combined cost number until nested-usage
+ * standardization lands.
+ *
+ * @example
+ * const support = ai.supervisor({ ... });
+ * const supportTool = support.asTool({
+ *   name: "handle_support_ticket",
+ *   description: "Process a customer support ticket end-to-end.",
+ *   inputSchema: z.object({ ticket: z.string() }),
+ * });
+ * const concierge = ai.agent({ model, tools: [supportTool] });
+ */
+declare function asTool<TOutput, TToolInput>(supervisorInstance: SupervisorContract<TOutput>, options: SupervisorAsToolOptions<TToolInput>): ToolContract<TToolInput, TOutput>;
+//#endregion
+export { asTool };
+//# sourceMappingURL=as-tool.d.mts.map

package/esm/supervisor/as-tool.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"as-tool.d.mts","names":[],"sources":["../../../../../../@warlock.js/ai/src/supervisor/as-tool.ts"],"mappings":";;;;;;AA4CA;;;;;;;;;;;;;;;;;;;;;;;;AAGmC;;;;;;;;;;;iBAHnB,MAAA,qBAAA,CACd,kBAAA,EAAoB,kBAAA,CAAmB,OAAA,GACvC,OAAA,EAAS,uBAAA,CAAwB,UAAA,IAChC,YAAA,CAAa,UAAA,EAAY,OAAA"}

package/esm/supervisor/as-tool.mjs

@@ -0,0 +1,80 @@
+import { SupervisorFailedError } from "../errors/supervisor-failed-error.mjs";
+import "../errors/index.mjs";
+import { compositeAsTool } from "../tool/tool.mjs";
+
+//#region ../../@warlock.js/ai/src/supervisor/as-tool.ts
+/**
+* Wrap a `SupervisorContract` as a `ToolContract` so an outer agent
+* can invoke it from its tool-call loop. Mirrors
+* `workflow.asTool()` / `agent.asTool()` — same composition pattern,
+* same error-normalization behavior.
+*
+* Behavior:
+* - The tool's `name` mirrors the supervisor's `name` unless the
+*   caller overrides via `options.name`. Supervisors without a
+*   meaningful name throw `SupervisorFailedError` — an outer agent
+*   can't route to an anonymous tool.
+* - Tool `input` is the supplied schema; the validated value is
+*   coerced to a string (via `String()` for non-string values, or
+*   `JSON.stringify()` for objects) before being forwarded to
+*   `supervisor.execute(input)`. Consumers whose inputs need
+*   richer shaping should pre-format the string themselves.
+* - On `result.error`, the supervisor error is thrown so the tool
+*   wrapper catches it and produces a `ToolExecutionError` with
+*   `cause` set to the original typed supervisor error — the outer
+*   agent sees one uniform error class regardless of which
+*   primitive failed.
+*
+* **Usage caveat** (mirrors workflow-as-tool): nested usage is not
+* rolled into the outer agent's `result.usage` today — the
+* supervisor's tokens stay on the supervisor result. Sum manually
+* if you need a combined cost number until nested-usage
+* standardization lands.
+*
+* @example
+* const support = ai.supervisor({ ... });
+* const supportTool = support.asTool({
+*   name: "handle_support_ticket",
+*   description: "Process a customer support ticket end-to-end.",
+*   inputSchema: z.object({ ticket: z.string() }),
+* });
+* const concierge = ai.agent({ model, tools: [supportTool] });
+*/
+function asTool(supervisorInstance, options) {
+	if (!supervisorInstance.name || typeof supervisorInstance.name !== "string") throw new SupervisorFailedError("supervisor.asTool(): supervisor must have a `name` to be wrapped as a tool");
+	return compositeAsTool({
+		name: options.name ?? supervisorInstance.name,
+		description: options.description ?? `Invoke supervisor "${supervisorInstance.name}" as a tool.`,
+		input: options.inputSchema,
+		execute: async (input) => {
+			const coerced = coerceInput(input);
+			const result = await supervisorInstance.execute(coerced);
+			if (result.error) throw result.error;
+			return {
+				data: result.data,
+				usage: result.usage,
+				report: result.report
+			};
+		}
+	});
+}
+/**
+* Coerce a tool-input value into the `string` shape supervisor
+* `execute()` expects. Strings pass through; everything else gets
+* JSON-stringified so supervisors invoked via tool wrappers receive a
+* predictable textual input regardless of how the outer agent shaped
+* its call.
+*/
+function coerceInput(value) {
+	if (typeof value === "string") return value;
+	if (value === void 0 || value === null) return "";
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return String(value);
+	}
+}
+
+//#endregion
+export { asTool };
+//# sourceMappingURL=as-tool.mjs.map

package/esm/supervisor/as-tool.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"as-tool.mjs","names":[],"sources":["../../../../../../@warlock.js/ai/src/supervisor/as-tool.ts"],"sourcesContent":["import type {\n  SupervisorAsToolOptions,\n  SupervisorContract,\n} from \"../contracts/supervisor/supervisor.contract\";\nimport { SupervisorFailedError } from \"../errors\";\nimport { compositeAsTool, type ToolContract } from \"../tool/tool\";\n\n/**\n * Wrap a `SupervisorContract` as a `ToolContract` so an outer agent\n * can invoke it from its tool-call loop. Mirrors\n * `workflow.asTool()` / `agent.asTool()` — same composition pattern,\n * same error-normalization behavior.\n *\n * Behavior:\n * - The tool's `name` mirrors the supervisor's `name` unless the\n *   caller overrides via `options.name`. Supervisors without a\n *   meaningful name throw `SupervisorFailedError` — an outer agent\n *   can't route to an anonymous tool.\n * - Tool `input` is the supplied schema; the validated value is\n *   coerced to a string (via `String()` for non-string values, or\n *   `JSON.stringify()` for objects) before being forwarded to\n *   `supervisor.execute(input)`. Consumers whose inputs need\n *   richer shaping should pre-format the string themselves.\n * - On `result.error`, the supervisor error is thrown so the tool\n *   wrapper catches it and produces a `ToolExecutionError` with\n *   `cause` set to the original typed supervisor error — the outer\n *   agent sees one uniform error class regardless of which\n *   primitive failed.\n *\n * **Usage caveat** (mirrors workflow-as-tool): nested usage is not\n * rolled into the outer agent's `result.usage` today — the\n * supervisor's tokens stay on the supervisor result. Sum manually\n * if you need a combined cost number until nested-usage\n * standardization lands.\n *\n * @example\n * const support = ai.supervisor({ ... });\n * const supportTool = support.asTool({\n *   name: \"handle_support_ticket\",\n *   description: \"Process a customer support ticket end-to-end.\",\n *   inputSchema: z.object({ ticket: z.string() }),\n * });\n * const concierge = ai.agent({ model, tools: [supportTool] });\n */\nexport function asTool<TOutput, TToolInput>(\n  supervisorInstance: SupervisorContract<TOutput>,\n  options: SupervisorAsToolOptions<TToolInput>,\n): ToolContract<TToolInput, TOutput> {\n  if (!supervisorInstance.name || typeof supervisorInstance.name !== \"string\") {\n    throw new SupervisorFailedError(\n      \"supervisor.asTool(): supervisor must have a `name` to be wrapped as a tool\",\n    );\n  }\n\n  return compositeAsTool<TToolInput, TOutput>({\n    name: options.name ?? supervisorInstance.name,\n    description: options.description ?? `Invoke supervisor \"${supervisorInstance.name}\" as a tool.`,\n    input: options.inputSchema,\n    execute: async (input) => {\n      const coerced = coerceInput(input);\n      const result = await supervisorInstance.execute(coerced);\n\n      if (result.error) {\n        // Surface the typed supervisor error — the outer ToolContract\n        // wraps it as a ToolExecutionError with `cause` preserved.\n        throw result.error;\n      }\n\n      return {\n        data: result.data as TOutput,\n        usage: result.usage,\n        report: result.report,\n      };\n    },\n  });\n}\n\n/**\n * Coerce a tool-input value into the `string` shape supervisor\n * `execute()` expects. Strings pass through; everything else gets\n * JSON-stringified so supervisors invoked via tool wrappers receive a\n * predictable textual input regardless of how the outer agent shaped\n * its call.\n */\nfunction coerceInput(value: unknown): string {\n  if (typeof value === \"string\") {\n    return value;\n  }\n\n  if (value === undefined || value === null) {\n    return \"\";\n  }\n\n  try {\n    return JSON.stringify(value);\n  } catch {\n    return String(value);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,SAAgB,OACd,oBACA,SACmC;CACnC,IAAI,CAAC,mBAAmB,QAAQ,OAAO,mBAAmB,SAAS,UACjE,MAAM,IAAI,sBACR,4EACF;CAGF,OAAO,gBAAqC;EAC1C,MAAM,QAAQ,QAAQ,mBAAmB;EACzC,aAAa,QAAQ,eAAe,sBAAsB,mBAAmB,KAAK;EAClF,OAAO,QAAQ;EACf,SAAS,OAAO,UAAU;GACxB,MAAM,UAAU,YAAY,KAAK;GACjC,MAAM,SAAS,MAAM,mBAAmB,QAAQ,OAAO;GAEvD,IAAI,OAAO,OAGT,MAAM,OAAO;GAGf,OAAO;IACL,MAAM,OAAO;IACb,OAAO,OAAO;IACd,QAAQ,OAAO;GACjB;EACF;CACF,CAAC;AACH;;;;;;;;AASA,SAAS,YAAY,OAAwB;CAC3C,IAAI,OAAO,UAAU,UACnB,OAAO;CAGT,IAAI,UAAU,UAAa,UAAU,MACnC,OAAO;CAGT,IAAI;EACF,OAAO,KAAK,UAAU,KAAK;CAC7B,QAAQ;EACN,OAAO,OAAO,KAAK;CACrB;AACF"}

package/esm/supervisor/cancellation.d.mts

@@ -0,0 +1,12 @@
+import { SupervisorCancelledError } from "../errors/supervisor-cancelled-error.mjs";
+//#region ../../@warlock.js/ai/src/supervisor/cancellation.d.ts
+/**
+ * Build a `SupervisorCancelledError` from an `AbortSignal`. Extracts a
+ * human-readable reason from `signal.reason` whether it was a string,
+ * an `Error`, or some other value. Used at between-iteration boundaries
+ * and on any mid-iteration cancellation path.
+ */
+declare function createCancelledError(signal: AbortSignal | undefined): SupervisorCancelledError;
+//#endregion
+export { createCancelledError };
+//# sourceMappingURL=cancellation.d.mts.map

package/esm/supervisor/cancellation.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cancellation.d.mts","names":[],"sources":["../../../../../../@warlock.js/ai/src/supervisor/cancellation.ts"],"mappings":";;;;;AAQA;;;iBAAgB,oBAAA,CACd,MAAA,EAAQ,WAAA,eACP,wBAAwB"}