@anvia/core 1.1.2 → 1.2.1

package/dist/agent/tool-state.js

@@ -0,0 +1,11 @@
+import {
+  getAgentToolState,
+  getRegisteredAgentTool,
+  registerAgentToolState
+} from "../chunk-A7BXVZXZ.js";
+export {
+  getAgentToolState,
+  getRegisteredAgentTool,
+  registerAgentToolState
+};
+//# sourceMappingURL=tool-state.js.map

package/dist/agent/tool-state.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/agent/types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=types.js.map

package/dist/agent/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/agent/vector-context.js

@@ -0,0 +1,10 @@
+import {
+  createVectorContext,
+  isVectorContext
+} from "../chunk-ZHC5CD6J.js";
+import "../chunk-5V533R7F.js";
+export {
+  createVectorContext,
+  isVectorContext
+};
+//# sourceMappingURL=vector-context.js.map

package/dist/agent/vector-context.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/{agent-DTmzs1Qr.d.ts → agent-C9VhENdj.d.ts}

@@ -1,11 +1,10 @@
 import { b as RetrySetting } from './retry-CjvSlKGW.js';
 import { D as Document, d as CompletionModel, P as ProviderTool, J as JsonObject, C as CompletionControlValues, f as CompletionModelControlsOf, z as ToolChoice } from './types-CiHjqE6J.js';
 import { Z as ZodSchema } from './zod-schema-C7F4clpm.js';
-import { d as GuardrailPolicyInput, c as GuardrailPolicy } from './types-h0EL6Xn0.js';
+import { d as GuardrailPolicyInput, c as GuardrailPolicy } from './types-Bqw0AuFl.js';
 import { a as McpServer } from './types-DfRPfehE.js';
 import { E as MemoryStore, z as MemorySavePolicy, F as MemoryTokenCounter, n as MemoryCompactor, d as MemoryCompactionConflictRetryOptions, y as MemoryOptions, k as MemoryCompactionResult } from './types-CafU6Ux5.js';
-import { h as AgentLifecycle, F as AgentObservabilityOptions, n as AgentRunOptions, k as AgentOutcome, o as AgentRunSettings, t as AgentStream, j as AgentMemoryCompactionOptions } from './types-CRda8x7p.js';
-import { A as AgentMiddleware } from './middleware-mY_lpjDp.js';
+import { h as AgentLifecycle, P as AgentObservabilityOptions, k as AgentMiddleware, o as AgentRunOptions, l as AgentOutcome, p as AgentRunSettings, u as AgentStream, j as AgentMemoryCompactionOptions } from './middleware-CWjnMbiH.js';
 import { A as AnyTool, T as Tool, c as ToolCallContext, N as NormalizedToolOutput } from './tool-DQMZpZSS.js';
 import { AgentContinuation, AgentInteractionResponse } from './agent/interactions/index.js';
 import { a as SkillSet } from './types-C1xYKXF2.js';

package/dist/{chunk-I3Q7XSBB.js → chunk-23LRXKQX.js}

@@ -1,11 +1,13 @@
 import {
   assertJsonObject
-} from "./chunk-7JLAIN6E.js";
+} from "./chunk-4ONUNWGC.js";
 import {
   resolveRetryOptions,
-  runWithRetries,
+  runWithRetries
+} from "./chunk-POXHJF3H.js";
+import {
   throwIfAborted
-} from "./chunk-3RWESPUG.js";
+} from "./chunk-USRKPEQN.js";
 
 // src/image-generation/generate-image.ts
 async function generateImage(options) {
@@ -56,4 +58,4 @@ function assertPositiveInteger(value, name) {
 export {
   generateImage
 };
-//# sourceMappingURL=chunk-I3Q7XSBB.js.map
+//# sourceMappingURL=chunk-23LRXKQX.js.map

package/dist/{chunk-I3Q7XSBB.js.map → chunk-23LRXKQX.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/image-generation/generate-image.ts"],"sourcesContent":["import type { JsonObject } from \"../completion/types\";\nimport { throwIfAborted } from \"../internal/abort\";\nimport { assertJsonObject } from \"../internal/json-object\";\nimport type { ModelCallOptions } from \"../model-call-options\";\nimport {\n  type ResolvedRetryOptions,\n  type RetrySetting,\n  resolveRetryOptions,\n  runWithRetries,\n} from \"../retry\";\nimport type { ImageGenerationModel, ImageGenerationRequest, ImageGenerationResult } from \"./types\";\n\nexport type GenerateImageOptions<Model extends ImageGenerationModel = ImageGenerationModel> = {\n  model: Model;\n  prompt: string;\n  width?: number | undefined;\n  height?: number | undefined;\n  providerOptions?: JsonObject | undefined;\n  retries?: RetrySetting | undefined;\n  abortSignal?: AbortSignal | undefined;\n};\n\ntype RawResponseOf<Model> =\n  Model extends ImageGenerationModel<infer RawResponse> ? RawResponse : unknown;\n\nexport async function generateImage<Model extends ImageGenerationModel>(\n  options: GenerateImageOptions<Model>,\n): Promise<ImageGenerationResult<RawResponseOf<Model>>> {\n  assertNonEmptyString(options.prompt, \"Image prompt\");\n  throwIfAborted(options.abortSignal);\n  const width = options.width ?? 1024;\n  const height = options.height ?? 1024;\n  assertPositiveInteger(width, \"Image width\");\n  assertPositiveInteger(height, \"Image height\");\n\n  const request: ImageGenerationRequest = { prompt: options.prompt, width, height };\n  if (options.providerOptions !== undefined) {\n    assertJsonObject(options.providerOptions, \"providerOptions\");\n    request.providerOptions = options.providerOptions;\n  }\n  const result = await runWithRetries(\n    () => {\n      throwIfAborted(options.abortSignal);\n      return options.model.imageGeneration(\n        request,\n        modelCallOptions(options.abortSignal),\n      ) as Promise<ImageGenerationResult<RawResponseOf<Model>>>;\n    },\n    resolveRetries(options.retries),\n    { streaming: false, abortSignal: options.abortSignal },\n  );\n  if (!Array.isArray(result.images) || result.images.length === 0) {\n    throw new Error(\"The image generation model returned no images.\");\n  }\n  return result;\n}\n\nfunction resolveRetries(setting: RetrySetting | undefined): ResolvedRetryOptions | undefined {\n  return setting === undefined || setting === false ? undefined : resolveRetryOptions(setting);\n}\n\nfunction modelCallOptions(abortSignal: AbortSignal | undefined): ModelCallOptions | undefined {\n  return abortSignal === undefined ? undefined : { abortSignal };\n}\n\nfunction assertNonEmptyString(value: string, name: string): void {\n  if (typeof value !== \"string\" || value.trim().length === 0) {\n    throw new TypeError(`${name} must be a non-empty string.`);\n  }\n}\n\nfunction assertPositiveInteger(value: number, name: string): void {\n  if (!Number.isSafeInteger(value) || value < 1) {\n    throw new RangeError(`${name} must be a positive integer.`);\n  }\n}\n"],"mappings":";;;;;;;;;;AAyBA,eAAsB,cACpB,SACsD;AACtD,uBAAqB,QAAQ,QAAQ,cAAc;AACnD,iBAAe,QAAQ,WAAW;AAClC,QAAM,QAAQ,QAAQ,SAAS;AAC/B,QAAM,SAAS,QAAQ,UAAU;AACjC,wBAAsB,OAAO,aAAa;AAC1C,wBAAsB,QAAQ,cAAc;AAE5C,QAAM,UAAkC,EAAE,QAAQ,QAAQ,QAAQ,OAAO,OAAO;AAChF,MAAI,QAAQ,oBAAoB,QAAW;AACzC,qBAAiB,QAAQ,iBAAiB,iBAAiB;AAC3D,YAAQ,kBAAkB,QAAQ;AAAA,EACpC;AACA,QAAM,SAAS,MAAM;AAAA,IACnB,MAAM;AACJ,qBAAe,QAAQ,WAAW;AAClC,aAAO,QAAQ,MAAM;AAAA,QACnB;AAAA,QACA,iBAAiB,QAAQ,WAAW;AAAA,MACtC;AAAA,IACF;AAAA,IACA,eAAe,QAAQ,OAAO;AAAA,IAC9B,EAAE,WAAW,OAAO,aAAa,QAAQ,YAAY;AAAA,EACvD;AACA,MAAI,CAAC,MAAM,QAAQ,OAAO,MAAM,KAAK,OAAO,OAAO,WAAW,GAAG;AAC/D,UAAM,IAAI,MAAM,gDAAgD;AAAA,EAClE;AACA,SAAO;AACT;AAEA,SAAS,eAAe,SAAqE;AAC3F,SAAO,YAAY,UAAa,YAAY,QAAQ,SAAY,oBAAoB,OAAO;AAC7F;AAEA,SAAS,iBAAiB,aAAoE;AAC5F,SAAO,gBAAgB,SAAY,SAAY,EAAE,YAAY;AAC/D;AAEA,SAAS,qBAAqB,OAAe,MAAoB;AAC/D,MAAI,OAAO,UAAU,YAAY,MAAM,KAAK,EAAE,WAAW,GAAG;AAC1D,UAAM,IAAI,UAAU,GAAG,IAAI,8BAA8B;AAAA,EAC3D;AACF;AAEA,SAAS,sBAAsB,OAAe,MAAoB;AAChE,MAAI,CAAC,OAAO,cAAc,KAAK,KAAK,QAAQ,GAAG;AAC7C,UAAM,IAAI,WAAW,GAAG,IAAI,8BAA8B;AAAA,EAC5D;AACF;","names":[]}
+{"version":3,"sources":["../src/image-generation/generate-image.ts"],"sourcesContent":["import type { JsonObject } from \"../completion/types\";\nimport { throwIfAborted } from \"../internal/abort\";\nimport { assertJsonObject } from \"../internal/json-object\";\nimport type { ModelCallOptions } from \"../model-call-options\";\nimport {\n  type ResolvedRetryOptions,\n  type RetrySetting,\n  resolveRetryOptions,\n  runWithRetries,\n} from \"../retry\";\nimport type { ImageGenerationModel, ImageGenerationRequest, ImageGenerationResult } from \"./types\";\n\nexport type GenerateImageOptions<Model extends ImageGenerationModel = ImageGenerationModel> = {\n  model: Model;\n  prompt: string;\n  width?: number | undefined;\n  height?: number | undefined;\n  providerOptions?: JsonObject | undefined;\n  retries?: RetrySetting | undefined;\n  abortSignal?: AbortSignal | undefined;\n};\n\ntype RawResponseOf<Model> =\n  Model extends ImageGenerationModel<infer RawResponse> ? RawResponse : unknown;\n\nexport async function generateImage<Model extends ImageGenerationModel>(\n  options: GenerateImageOptions<Model>,\n): Promise<ImageGenerationResult<RawResponseOf<Model>>> {\n  assertNonEmptyString(options.prompt, \"Image prompt\");\n  throwIfAborted(options.abortSignal);\n  const width = options.width ?? 1024;\n  const height = options.height ?? 1024;\n  assertPositiveInteger(width, \"Image width\");\n  assertPositiveInteger(height, \"Image height\");\n\n  const request: ImageGenerationRequest = { prompt: options.prompt, width, height };\n  if (options.providerOptions !== undefined) {\n    assertJsonObject(options.providerOptions, \"providerOptions\");\n    request.providerOptions = options.providerOptions;\n  }\n  const result = await runWithRetries(\n    () => {\n      throwIfAborted(options.abortSignal);\n      return options.model.imageGeneration(\n        request,\n        modelCallOptions(options.abortSignal),\n      ) as Promise<ImageGenerationResult<RawResponseOf<Model>>>;\n    },\n    resolveRetries(options.retries),\n    { streaming: false, abortSignal: options.abortSignal },\n  );\n  if (!Array.isArray(result.images) || result.images.length === 0) {\n    throw new Error(\"The image generation model returned no images.\");\n  }\n  return result;\n}\n\nfunction resolveRetries(setting: RetrySetting | undefined): ResolvedRetryOptions | undefined {\n  return setting === undefined || setting === false ? undefined : resolveRetryOptions(setting);\n}\n\nfunction modelCallOptions(abortSignal: AbortSignal | undefined): ModelCallOptions | undefined {\n  return abortSignal === undefined ? undefined : { abortSignal };\n}\n\nfunction assertNonEmptyString(value: string, name: string): void {\n  if (typeof value !== \"string\" || value.trim().length === 0) {\n    throw new TypeError(`${name} must be a non-empty string.`);\n  }\n}\n\nfunction assertPositiveInteger(value: number, name: string): void {\n  if (!Number.isSafeInteger(value) || value < 1) {\n    throw new RangeError(`${name} must be a positive integer.`);\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAyBA,eAAsB,cACpB,SACsD;AACtD,uBAAqB,QAAQ,QAAQ,cAAc;AACnD,iBAAe,QAAQ,WAAW;AAClC,QAAM,QAAQ,QAAQ,SAAS;AAC/B,QAAM,SAAS,QAAQ,UAAU;AACjC,wBAAsB,OAAO,aAAa;AAC1C,wBAAsB,QAAQ,cAAc;AAE5C,QAAM,UAAkC,EAAE,QAAQ,QAAQ,QAAQ,OAAO,OAAO;AAChF,MAAI,QAAQ,oBAAoB,QAAW;AACzC,qBAAiB,QAAQ,iBAAiB,iBAAiB;AAC3D,YAAQ,kBAAkB,QAAQ;AAAA,EACpC;AACA,QAAM,SAAS,MAAM;AAAA,IACnB,MAAM;AACJ,qBAAe,QAAQ,WAAW;AAClC,aAAO,QAAQ,MAAM;AAAA,QACnB;AAAA,QACA,iBAAiB,QAAQ,WAAW;AAAA,MACtC;AAAA,IACF;AAAA,IACA,eAAe,QAAQ,OAAO;AAAA,IAC9B,EAAE,WAAW,OAAO,aAAa,QAAQ,YAAY;AAAA,EACvD;AACA,MAAI,CAAC,MAAM,QAAQ,OAAO,MAAM,KAAK,OAAO,OAAO,WAAW,GAAG;AAC/D,UAAM,IAAI,MAAM,gDAAgD;AAAA,EAClE;AACA,SAAO;AACT;AAEA,SAAS,eAAe,SAAqE;AAC3F,SAAO,YAAY,UAAa,YAAY,QAAQ,SAAY,oBAAoB,OAAO;AAC7F;AAEA,SAAS,iBAAiB,aAAoE;AAC5F,SAAO,gBAAgB,SAAY,SAAY,EAAE,YAAY;AAC/D;AAEA,SAAS,qBAAqB,OAAe,MAAoB;AAC/D,MAAI,OAAO,UAAU,YAAY,MAAM,KAAK,EAAE,WAAW,GAAG;AAC1D,UAAM,IAAI,UAAU,GAAG,IAAI,8BAA8B;AAAA,EAC3D;AACF;AAEA,SAAS,sBAAsB,OAAe,MAAoB;AAChE,MAAI,CAAC,OAAO,cAAc,KAAK,KAAK,QAAQ,GAAG;AAC7C,UAAM,IAAI,WAAW,GAAG,IAAI,8BAA8B;AAAA,EAC5D;AACF;","names":[]}

package/dist/{chunk-YK4WAAS4.js → chunk-2NLINXRF.js}

@@ -15,4 +15,4 @@ export {
   markSkillTool,
   isSkillTool
 };
-//# sourceMappingURL=chunk-YK4WAAS4.js.map
+//# sourceMappingURL=chunk-2NLINXRF.js.map

package/dist/{chunk-SPD4XVR7.js → chunk-2XSMGVBG.js}

@@ -26,4 +26,4 @@ function isJsonObject(value) {
 export {
   createMemoryScopeKey
 };
-//# sourceMappingURL=chunk-SPD4XVR7.js.map
+//# sourceMappingURL=chunk-2XSMGVBG.js.map

package/dist/chunk-3J2CSVPR.js

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-3J2CSVPR.js.map

package/dist/chunk-3J2CSVPR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-3P3YVJ7V.js

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-3P3YVJ7V.js.map

package/dist/chunk-3P3YVJ7V.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-3TAQXJBC.js

@@ -0,0 +1,107 @@
+import {
+  AgentTeamLimitError
+} from "./chunk-ENZ2XX27.js";
+import {
+  createAsyncQueue
+} from "./chunk-EZR5AV3J.js";
+
+// src/internal/team-runtime/stream.ts
+var TeamStream = class {
+  queue = createAsyncQueue();
+  run;
+  promise;
+  mode;
+  iterating = false;
+  bufferedEvents = 0;
+  bufferError;
+  constructor(createRun, maxBufferedEvents) {
+    this.run = createRun((event) => {
+      if (this.mode !== "events" || this.bufferError !== void 0) return;
+      if (this.bufferedEvents >= maxBufferedEvents) {
+        this.bufferError = new AgentTeamLimitError("maxBufferedEvents");
+        this.queue.throw(this.bufferError, { discardPending: true });
+        this.run.cancel("Agent team stream exceeded maxBufferedEvents.");
+        return;
+      }
+      this.bufferedEvents += 1;
+      this.queue.enqueue(event);
+    });
+  }
+  get events() {
+    return this;
+  }
+  get textStream() {
+    return this.consumeText();
+  }
+  get result() {
+    if (this.mode === void 0)
+      queueMicrotask(() => {
+        this.mode ??= "result";
+      });
+    return this.start();
+  }
+  get text() {
+    return this.result.then((outcome) => outcome.text);
+  }
+  steer(input) {
+    return this.run.steer(input);
+  }
+  cancel(reason) {
+    this.run.cancel(reason);
+  }
+  [Symbol.asyncIterator]() {
+    return this.consume();
+  }
+  start() {
+    if (this.promise === void 0) {
+      this.promise = this.run.execute().then(
+        (outcome) => {
+          if (this.bufferError !== void 0) throw this.bufferError;
+          return outcome;
+        },
+        (error) => {
+          throw this.bufferError ?? error;
+        }
+      );
+      this.promise.then(
+        () => this.queue.close(),
+        (error) => this.queue.throw(error)
+      );
+    }
+    return this.promise;
+  }
+  async *consume() {
+    if (this.mode !== void 0 || this.iterating)
+      throw new Error("Agent team stream already has a consumer.");
+    this.mode = "events";
+    this.iterating = true;
+    void this.start();
+    let completed = false;
+    try {
+      for await (const event of this.queue) {
+        if (this.bufferError !== void 0) throw this.bufferError;
+        this.bufferedEvents -= 1;
+        yield event;
+      }
+      completed = true;
+    } finally {
+      if (!completed) {
+        this.mode = "result";
+        this.run.cancel("Agent team stream consumer closed.");
+        this.queue.close({ discardPending: true });
+      }
+      this.iterating = false;
+    }
+  }
+  async *consumeText() {
+    for await (const event of this) {
+      if (event.type === "agent_event" && event.coordinator && event.event.type === "text_delta")
+        yield event.event.delta;
+    }
+  }
+};
+
+export {
+  TeamStream
+};
+//# sourceMappingURL=chunk-3TAQXJBC.js.map

package/dist/chunk-3TAQXJBC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internal/team-runtime/stream.ts"],"sourcesContent":["import type { AgentSteerInput, AgentSteerReceipt } from \"../../agent/run-types\";\nimport type { AgentTeamEvent, AgentTeamOutcome, AgentTeamStream } from \"../../agent/team/types\";\nimport { AgentTeamLimitError } from \"../../agent/team/errors\";\nimport { createAsyncQueue } from \"../async-queue\";\nimport type { TeamRun } from \"./run\";\n\n/** Events and final promises share one consumption mode, matching AgentStream. */\nexport class TeamStream<Output> implements AgentTeamStream<Output> {\n  private readonly queue = createAsyncQueue<AgentTeamEvent<Output>>();\n  private readonly run: TeamRun<Output>;\n  private promise: Promise<AgentTeamOutcome<Output>> | undefined;\n  private mode: \"events\" | \"result\" | undefined;\n  private iterating = false;\n  private bufferedEvents = 0;\n  private bufferError: AgentTeamLimitError | undefined;\n\n  constructor(\n    createRun: (emit: (event: AgentTeamEvent<Output>) => void) => TeamRun<Output>,\n    maxBufferedEvents: number,\n  ) {\n    this.run = createRun((event) => {\n      if (this.mode !== \"events\" || this.bufferError !== undefined) return;\n      if (this.bufferedEvents >= maxBufferedEvents) {\n        // Set the error before cancelling: cancellation emits further member events.\n        this.bufferError = new AgentTeamLimitError(\"maxBufferedEvents\");\n        this.queue.throw(this.bufferError, { discardPending: true });\n        this.run.cancel(\"Agent team stream exceeded maxBufferedEvents.\");\n        return;\n      }\n      this.bufferedEvents += 1;\n      this.queue.enqueue(event);\n    });\n  }\n\n  get events(): AsyncIterable<AgentTeamEvent<Output>> {\n    return this;\n  }\n  get textStream(): AsyncIterable<string> {\n    return this.consumeText();\n  }\n  get result(): Promise<AgentTeamOutcome<Output>> {\n    // Let a synchronous event subscription win, as with AgentStream.result.\n    if (this.mode === undefined)\n      queueMicrotask(() => {\n        this.mode ??= \"result\";\n      });\n    return this.start();\n  }\n  get text(): Promise<string> {\n    return this.result.then((outcome) => outcome.text);\n  }\n\n  steer(input: AgentSteerInput): AgentSteerReceipt {\n    return this.run.steer(input);\n  }\n  cancel(reason?: string): void {\n    this.run.cancel(reason);\n  }\n\n  [Symbol.asyncIterator](): AsyncIterator<AgentTeamEvent<Output>> {\n    return this.consume();\n  }\n\n  private start(): Promise<AgentTeamOutcome<Output>> {\n    if (this.promise === undefined) {\n      this.promise = this.run.execute().then(\n        (outcome) => {\n          // Overflow can occur while publishing the terminal outcome, after the run closes.\n          if (this.bufferError !== undefined) throw this.bufferError;\n          return outcome;\n        },\n        (error: unknown) => {\n          throw this.bufferError ?? error;\n        },\n      );\n      // Observe failures for iterator-only consumers. queue.throw records the error and returns.\n      this.promise.then(\n        () => this.queue.close(),\n        (error: unknown) => this.queue.throw(error),\n      );\n    }\n    return this.promise;\n  }\n\n  private async *consume(): AsyncIterableIterator<AgentTeamEvent<Output>> {\n    if (this.mode !== undefined || this.iterating)\n      throw new Error(\"Agent team stream already has a consumer.\");\n    this.mode = \"events\";\n    this.iterating = true;\n    void this.start();\n    let completed = false;\n    try {\n      for await (const event of this.queue) {\n        if (this.bufferError !== undefined) throw this.bufferError;\n        this.bufferedEvents -= 1;\n        yield event;\n      }\n      completed = true;\n    } finally {\n      if (!completed) {\n        this.mode = \"result\";\n        this.run.cancel(\"Agent team stream consumer closed.\");\n        this.queue.close({ discardPending: true });\n      }\n      this.iterating = false;\n    }\n  }\n\n  private async *consumeText(): AsyncIterableIterator<string> {\n    for await (const event of this) {\n      if (event.type === \"agent_event\" && event.coordinator && event.event.type === \"text_delta\")\n        yield event.event.delta;\n    }\n  }\n}\n"],"mappings":";;;;;;;;AAOO,IAAM,aAAN,MAA4D;AAAA,EAChD,QAAQ,iBAAyC;AAAA,EACjD;AAAA,EACT;AAAA,EACA;AAAA,EACA,YAAY;AAAA,EACZ,iBAAiB;AAAA,EACjB;AAAA,EAER,YACE,WACA,mBACA;AACA,SAAK,MAAM,UAAU,CAAC,UAAU;AAC9B,UAAI,KAAK,SAAS,YAAY,KAAK,gBAAgB,OAAW;AAC9D,UAAI,KAAK,kBAAkB,mBAAmB;AAE5C,aAAK,cAAc,IAAI,oBAAoB,mBAAmB;AAC9D,aAAK,MAAM,MAAM,KAAK,aAAa,EAAE,gBAAgB,KAAK,CAAC;AAC3D,aAAK,IAAI,OAAO,+CAA+C;AAC/D;AAAA,MACF;AACA,WAAK,kBAAkB;AACvB,WAAK,MAAM,QAAQ,KAAK;AAAA,IAC1B,CAAC;AAAA,EACH;AAAA,EAEA,IAAI,SAAgD;AAClD,WAAO;AAAA,EACT;AAAA,EACA,IAAI,aAAoC;AACtC,WAAO,KAAK,YAAY;AAAA,EAC1B;AAAA,EACA,IAAI,SAA4C;AAE9C,QAAI,KAAK,SAAS;AAChB,qBAAe,MAAM;AACnB,aAAK,SAAS;AAAA,MAChB,CAAC;AACH,WAAO,KAAK,MAAM;AAAA,EACpB;AAAA,EACA,IAAI,OAAwB;AAC1B,WAAO,KAAK,OAAO,KAAK,CAAC,YAAY,QAAQ,IAAI;AAAA,EACnD;AAAA,EAEA,MAAM,OAA2C;AAC/C,WAAO,KAAK,IAAI,MAAM,KAAK;AAAA,EAC7B;AAAA,EACA,OAAO,QAAuB;AAC5B,SAAK,IAAI,OAAO,MAAM;AAAA,EACxB;AAAA,EAEA,CAAC,OAAO,aAAa,IAA2C;AAC9D,WAAO,KAAK,QAAQ;AAAA,EACtB;AAAA,EAEQ,QAA2C;AACjD,QAAI,KAAK,YAAY,QAAW;AAC9B,WAAK,UAAU,KAAK,IAAI,QAAQ,EAAE;AAAA,QAChC,CAAC,YAAY;AAEX,cAAI,KAAK,gBAAgB,OAAW,OAAM,KAAK;AAC/C,iBAAO;AAAA,QACT;AAAA,QACA,CAAC,UAAmB;AAClB,gBAAM,KAAK,eAAe;AAAA,QAC5B;AAAA,MACF;AAEA,WAAK,QAAQ;AAAA,QACX,MAAM,KAAK,MAAM,MAAM;AAAA,QACvB,CAAC,UAAmB,KAAK,MAAM,MAAM,KAAK;AAAA,MAC5C;AAAA,IACF;AACA,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,OAAe,UAAyD;AACtE,QAAI,KAAK,SAAS,UAAa,KAAK;AAClC,YAAM,IAAI,MAAM,2CAA2C;AAC7D,SAAK,OAAO;AACZ,SAAK,YAAY;AACjB,SAAK,KAAK,MAAM;AAChB,QAAI,YAAY;AAChB,QAAI;AACF,uBAAiB,SAAS,KAAK,OAAO;AACpC,YAAI,KAAK,gBAAgB,OAAW,OAAM,KAAK;AAC/C,aAAK,kBAAkB;AACvB,cAAM;AAAA,MACR;AACA,kBAAY;AAAA,IACd,UAAE;AACA,UAAI,CAAC,WAAW;AACd,aAAK,OAAO;AACZ,aAAK,IAAI,OAAO,oCAAoC;AACpD,aAAK,MAAM,MAAM,EAAE,gBAAgB,KAAK,CAAC;AAAA,MAC3C;AACA,WAAK,YAAY;AAAA,IACnB;AAAA,EACF;AAAA,EAEA,OAAe,cAA6C;AAC1D,qBAAiB,SAAS,MAAM;AAC9B,UAAI,MAAM,SAAS,iBAAiB,MAAM,eAAe,MAAM,MAAM,SAAS;AAC5E,cAAM,MAAM,MAAM;AAAA,IACtB;AAAA,EACF;AACF;","names":[]}

package/dist/chunk-47NTHIVB.js

@@ -0,0 +1,76 @@
+import {
+  parseMessage
+} from "./chunk-BONQTXRQ.js";
+import {
+  isJsonValue
+} from "./chunk-4C7AXYOM.js";
+
+// src/tool/tool.ts
+var richToolOutput = /* @__PURE__ */ Symbol.for("anvia.tool-output.content");
+var ToolResultSerializationError = class extends TypeError {
+  constructor(output) {
+    super("Tool output must be a string, a strict JSON value, or ToolOutput.content(...).");
+    this.output = output;
+    this.name = "ToolResultSerializationError";
+  }
+  output;
+};
+var ToolOutput = {
+  content(content) {
+    return { [richToolOutput]: true, content };
+  }
+};
+function normalizeToolResultOutput(output) {
+  if (typeof output === "string") {
+    return { type: "text", value: output };
+  }
+  if (isRichToolOutput(output)) {
+    try {
+      const message = parseMessage({
+        role: "tool",
+        content: [
+          {
+            type: "tool-result",
+            toolCallId: "validation",
+            toolName: "validation",
+            output: { type: "content", value: output.content }
+          }
+        ]
+      });
+      if (message.role !== "tool") throw new TypeError("Unexpected message role");
+      const result = message.content[0];
+      if (result?.type !== "tool-result") throw new TypeError("Unexpected tool result part");
+      if (result?.output.type !== "content") throw new TypeError("Unexpected tool output");
+      return result.output;
+    } catch {
+      throw new ToolResultSerializationError(output);
+    }
+  }
+  if (isJsonValue(output)) {
+    return { type: "json", value: output };
+  }
+  throw new ToolResultSerializationError(output);
+}
+function toolResultContentToText(content) {
+  return content.map((item) => item.type === "text" ? item.text : `[file:${item.mediaType}]`).join("\n");
+}
+function isRichToolOutput(value) {
+  if (typeof value !== "object" || value === null) return false;
+  return Object.getOwnPropertyDescriptor(value, richToolOutput)?.value === true;
+}
+function parseToolArgs(args) {
+  const value = JSON.parse(args);
+  if (!isJsonValue(value)) {
+    throw new TypeError("Tool arguments must be a JSON value.");
+  }
+  return value;
+}
+
+export {
+  ToolResultSerializationError,
+  ToolOutput,
+  normalizeToolResultOutput,
+  toolResultContentToText,
+  parseToolArgs
+};
+//# sourceMappingURL=chunk-47NTHIVB.js.map

package/dist/chunk-47NTHIVB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/tool/tool.ts"],"sourcesContent":["import { isJsonValue } from \"../completion/json\";\nimport { parseMessage } from \"../completion/message-schema\";\nimport type {\n  JsonObject,\n  JsonValue,\n  ToolDefinition,\n  ToolResultContentPart,\n  ToolResultOutput,\n} from \"../completion/types\";\n\nexport type ToolApprovalRunContext = {\n  agentId: string;\n  runId: string;\n  sessionId?: string;\n  metadata?: JsonObject;\n};\n\nexport type ToolApprovalContext<Args = unknown> = {\n  toolName: string;\n  args: Args;\n  rawArgs: string;\n  toolCallId: string;\n  callId?: string;\n  internalCallId: string;\n  run: ToolApprovalRunContext;\n};\n\nexport type ToolApprovalRequirement = {\n  reason?: string | undefined;\n};\n\nexport type ToolRequiresApproval<Args = unknown> =\n  | boolean\n  | ToolApprovalRequirement\n  | ((\n      args: Args,\n      context: ToolApprovalContext<Args>,\n    ) => boolean | ToolApprovalRequirement | Promise<boolean | ToolApprovalRequirement>);\n\nexport type ToolCallStreamEvent = {\n  agentId: string;\n  agentName?: string | undefined;\n  event: unknown;\n};\n\nexport type ToolCallContext = {\n  emitStreamEvent?(event: ToolCallStreamEvent): void | Promise<void>;\n  abortSignal?: AbortSignal | undefined;\n};\n\nexport interface Tool<Args = unknown, Output = unknown> {\n  readonly name: string;\n  readonly requiresApproval?: ToolRequiresApproval<Args>;\n  definition(prompt: string): ToolDefinition | Promise<ToolDefinition>;\n  call(args: Args, context?: ToolCallContext): Output | Promise<Output>;\n  parseInput?(args: JsonValue): Args;\n}\n\nexport type AnyTool = Omit<Tool<unknown, unknown>, \"requiresApproval\"> & {\n  readonly requiresApproval?: unknown;\n};\n\nconst richToolOutput: unique symbol = Symbol.for(\"anvia.tool-output.content\");\n\nexport type RichToolOutput = Readonly<{\n  [richToolOutput]: true;\n  content: readonly ToolResultContentPart[];\n}>;\n\nexport type NormalizedToolOutput = ToolResultOutput;\n\nexport class ToolResultSerializationError extends TypeError {\n  constructor(readonly output: unknown) {\n    super(\"Tool output must be a string, a strict JSON value, or ToolOutput.content(...).\");\n    this.name = \"ToolResultSerializationError\";\n  }\n}\n\nexport const ToolOutput = {\n  content(content: readonly ToolResultContentPart[]): RichToolOutput {\n    return { [richToolOutput]: true, content };\n  },\n};\n\nexport function normalizeToolResultOutput(output: unknown): NormalizedToolOutput {\n  if (typeof output === \"string\") {\n    return { type: \"text\", value: output };\n  }\n  if (isRichToolOutput(output)) {\n    try {\n      const message = parseMessage({\n        role: \"tool\",\n        content: [\n          {\n            type: \"tool-result\",\n            toolCallId: \"validation\",\n            toolName: \"validation\",\n            output: { type: \"content\", value: output.content },\n          },\n        ],\n      });\n      if (message.role !== \"tool\") throw new TypeError(\"Unexpected message role\");\n      const result = message.content[0];\n      if (result?.type !== \"tool-result\") throw new TypeError(\"Unexpected tool result part\");\n      if (result?.output.type !== \"content\") throw new TypeError(\"Unexpected tool output\");\n      return result.output;\n    } catch {\n      throw new ToolResultSerializationError(output);\n    }\n  }\n  if (isJsonValue(output)) {\n    return { type: \"json\", value: output };\n  }\n  throw new ToolResultSerializationError(output);\n}\n\nexport function toolResultContentToText(content: readonly ToolResultContentPart[]): string {\n  return content\n    .map((item) => (item.type === \"text\" ? item.text : `[file:${item.mediaType}]`))\n    .join(\"\\n\");\n}\n\nfunction isRichToolOutput(value: unknown): value is RichToolOutput {\n  if (typeof value !== \"object\" || value === null) return false;\n  return Object.getOwnPropertyDescriptor(value, richToolOutput)?.value === true;\n}\n\nexport function parseToolArgs(args: string): JsonValue {\n  const value: unknown = JSON.parse(args);\n  if (!isJsonValue(value)) {\n    throw new TypeError(\"Tool arguments must be a JSON value.\");\n  }\n  return value;\n}\n"],"mappings":";;;;;;;;AA8DA,IAAM,iBAAgC,uBAAO,IAAI,2BAA2B;AASrE,IAAM,+BAAN,cAA2C,UAAU;AAAA,EAC1D,YAAqB,QAAiB;AACpC,UAAM,gFAAgF;AADnE;AAEnB,SAAK,OAAO;AAAA,EACd;AAAA,EAHqB;AAIvB;AAEO,IAAM,aAAa;AAAA,EACxB,QAAQ,SAA2D;AACjE,WAAO,EAAE,CAAC,cAAc,GAAG,MAAM,QAAQ;AAAA,EAC3C;AACF;AAEO,SAAS,0BAA0B,QAAuC;AAC/E,MAAI,OAAO,WAAW,UAAU;AAC9B,WAAO,EAAE,MAAM,QAAQ,OAAO,OAAO;AAAA,EACvC;AACA,MAAI,iBAAiB,MAAM,GAAG;AAC5B,QAAI;AACF,YAAM,UAAU,aAAa;AAAA,QAC3B,MAAM;AAAA,QACN,SAAS;AAAA,UACP;AAAA,YACE,MAAM;AAAA,YACN,YAAY;AAAA,YACZ,UAAU;AAAA,YACV,QAAQ,EAAE,MAAM,WAAW,OAAO,OAAO,QAAQ;AAAA,UACnD;AAAA,QACF;AAAA,MACF,CAAC;AACD,UAAI,QAAQ,SAAS,OAAQ,OAAM,IAAI,UAAU,yBAAyB;AAC1E,YAAM,SAAS,QAAQ,QAAQ,CAAC;AAChC,UAAI,QAAQ,SAAS,cAAe,OAAM,IAAI,UAAU,6BAA6B;AACrF,UAAI,QAAQ,OAAO,SAAS,UAAW,OAAM,IAAI,UAAU,wBAAwB;AACnF,aAAO,OAAO;AAAA,IAChB,QAAQ;AACN,YAAM,IAAI,6BAA6B,MAAM;AAAA,IAC/C;AAAA,EACF;AACA,MAAI,YAAY,MAAM,GAAG;AACvB,WAAO,EAAE,MAAM,QAAQ,OAAO,OAAO;AAAA,EACvC;AACA,QAAM,IAAI,6BAA6B,MAAM;AAC/C;AAEO,SAAS,wBAAwB,SAAmD;AACzF,SAAO,QACJ,IAAI,CAAC,SAAU,KAAK,SAAS,SAAS,KAAK,OAAO,SAAS,KAAK,SAAS,GAAI,EAC7E,KAAK,IAAI;AACd;AAEA,SAAS,iBAAiB,OAAyC;AACjE,MAAI,OAAO,UAAU,YAAY,UAAU,KAAM,QAAO;AACxD,SAAO,OAAO,yBAAyB,OAAO,cAAc,GAAG,UAAU;AAC3E;AAEO,SAAS,cAAc,MAAyB;AACrD,QAAM,QAAiB,KAAK,MAAM,IAAI;AACtC,MAAI,CAAC,YAAY,KAAK,GAAG;AACvB,UAAM,IAAI,UAAU,sCAAsC;AAAA,EAC5D;AACA,SAAO;AACT;","names":[]}

package/dist/chunk-4AW2633B.js

@@ -0,0 +1,9 @@
+// src/tool/middleware.ts
+function createMiddleware(middleware) {
+  return middleware;
+}
+
+export {
+  createMiddleware
+};
+//# sourceMappingURL=chunk-4AW2633B.js.map

package/dist/chunk-4AW2633B.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/tool/middleware.ts"],"sourcesContent":["import type {\n  CompletionRequest,\n  CompletionResponse,\n  JsonValue,\n  ToolResultContentPart,\n} from \"../completion\";\nimport type { MaybePromise } from \"../internal/type-utils\";\nimport type { AgentRunPromptRef } from \"../observability/types\";\n\nexport type CompletionRequestMiddlewareArgs = {\n  turn: number;\n  request: CompletionRequest;\n  originalRequest: CompletionRequest;\n  /** Current generation identity, defaulting to the run's trace.promptRef each turn. */\n  promptRef?: AgentRunPromptRef | undefined;\n};\n\nexport type CompletionRequestMiddlewareResult =\n  | {\n      request: CompletionRequest;\n      /** Override this generation's identity; null explicitly clears the run default. */\n      promptRef?: AgentRunPromptRef | null | undefined;\n    }\n  | undefined;\n\nexport type CompletionResponseMiddlewareArgs<RawResponse = unknown> = {\n  turn: number;\n  request: CompletionRequest;\n  response: CompletionResponse<RawResponse>;\n  originalResponse: CompletionResponse<RawResponse>;\n};\n\nexport type CompletionResponseMiddlewareResult<RawResponse = unknown> =\n  | {\n      response: CompletionResponse<RawResponse>;\n    }\n  | undefined;\n\nexport type ToolInputMiddlewareArgs = {\n  toolName: string;\n  args: string;\n  originalArgs: string;\n  turn: number;\n  toolCallId?: string | undefined;\n  internalCallId: string;\n};\n\nexport type ToolInputMiddlewareResult =\n  | {\n      args: JsonValue | string;\n    }\n  | undefined;\n\nexport type ToolResultMiddlewareArgs = {\n  toolName: string;\n  args: string;\n  result: string;\n  originalResult: string;\n  structuredResult?: readonly ToolResultContentPart[] | undefined;\n  originalStructuredResult?: readonly ToolResultContentPart[] | undefined;\n  turn: number;\n  toolCallId?: string | undefined;\n  internalCallId: string;\n};\n\nexport type ToolOutputMiddlewareArgs = ToolResultMiddlewareArgs;\n\nexport type ToolOutputMiddlewareResult =\n  | string\n  | Readonly<{ result: string; structuredResult?: never }>\n  | Readonly<{\n      structuredResult: readonly ToolResultContentPart[];\n      result?: never;\n    }>\n  | undefined;\n\nexport interface AgentMiddleware<RawResponse = unknown> {\n  onCompletionRequest?(\n    args: CompletionRequestMiddlewareArgs,\n  ): MaybePromise<CompletionRequestMiddlewareResult>;\n  onCompletionResponse?(\n    args: CompletionResponseMiddlewareArgs<RawResponse>,\n  ): MaybePromise<CompletionResponseMiddlewareResult<RawResponse>>;\n  onToolInput?(args: ToolInputMiddlewareArgs): MaybePromise<ToolInputMiddlewareResult>;\n  onToolOutput?(args: ToolOutputMiddlewareArgs): MaybePromise<ToolOutputMiddlewareResult>;\n}\n\nexport function createMiddleware<RawResponse = unknown>(\n  middleware: AgentMiddleware<RawResponse>,\n): AgentMiddleware<RawResponse> {\n  return middleware;\n}\n"],"mappings":";AAuFO,SAAS,iBACd,YAC8B;AAC9B,SAAO;AACT;","names":[]}

package/dist/{chunk-3XQGVDU5.js → chunk-4C7AXYOM.js}

@@ -66,4 +66,4 @@ function hasOnlyDenseArrayProperties(value) {
 export {
   isJsonValue
 };
-//# sourceMappingURL=chunk-3XQGVDU5.js.map
+//# sourceMappingURL=chunk-4C7AXYOM.js.map

package/dist/{chunk-IZNOP6JG.js → chunk-4FIVU53H.js}

@@ -28,4 +28,4 @@ async function mapWithConcurrency(inputs, concurrency, mapper) {
 export {
   mapWithConcurrency
 };
-//# sourceMappingURL=chunk-IZNOP6JG.js.map
+//# sourceMappingURL=chunk-4FIVU53H.js.map

package/dist/chunk-4ITAV7YA.js

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-4ITAV7YA.js.map

package/dist/chunk-4ITAV7YA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/{chunk-7JLAIN6E.js → chunk-4ONUNWGC.js}

@@ -1,6 +1,6 @@
 import {
   isJsonValue
-} from "./chunk-3XQGVDU5.js";
+} from "./chunk-4C7AXYOM.js";
 
 // src/internal/json-object.ts
 function assertJsonObject(value, name) {
@@ -12,4 +12,4 @@ function assertJsonObject(value, name) {
 export {
   assertJsonObject
 };
-//# sourceMappingURL=chunk-7JLAIN6E.js.map
+//# sourceMappingURL=chunk-4ONUNWGC.js.map

package/dist/chunk-4S4OECPW.js

@@ -0,0 +1,158 @@
+import {
+  AgentRun
+} from "./chunk-RT5LUEO3.js";
+import {
+  assertNonnegativeSafeInteger
+} from "./chunk-NPJ2T3L5.js";
+import {
+  normalizeMemoryScope
+} from "./chunk-LAIATEUB.js";
+import {
+  AgentRunMemory
+} from "./chunk-F3E2RLC7.js";
+import {
+  prepareAgentTools
+} from "./chunk-MNYMLWWA.js";
+import {
+  getRegisteredAgentTool,
+  registerAgentToolState
+} from "./chunk-A7BXVZXZ.js";
+import {
+  registerAgentProviderOutputSchema
+} from "./chunk-GLMYZ6OA.js";
+import {
+  resolveAgentOptions
+} from "./chunk-5FCZ64HM.js";
+import {
+  cloneFrozenPlainData,
+  snapshotAgentContext,
+  snapshotAgentMemory,
+  snapshotAgentObservability,
+  snapshotGuardrailPolicies
+} from "./chunk-NVALGVQG.js";
+import {
+  createAgentStream
+} from "./chunk-KY4VXIN2.js";
+import {
+  createAgentTool
+} from "./chunk-PPJ7SYQL.js";
+import {
+  isStreamingCompletionModel
+} from "./chunk-BDKFFFVX.js";
+import {
+  assertJsonObject
+} from "./chunk-4ONUNWGC.js";
+import {
+  prepareToolCall
+} from "./chunk-MHOJJYDK.js";
+import {
+  ToolNotFoundError
+} from "./chunk-J6S6MT7O.js";
+import {
+  assertCompletionControlsSupported
+} from "./chunk-IDNL6IH4.js";
+import {
+  normalizeAgentId
+} from "./chunk-KBBQSP4M.js";
+
+// src/agent/agent.ts
+var DEFAULT_MAX_TURNS = 20;
+var Agent = class {
+  id;
+  name;
+  description;
+  model;
+  instructions;
+  context;
+  temperature;
+  maxTokens;
+  providerOptions;
+  controls;
+  retries;
+  mcpServers;
+  tools;
+  toolChoice;
+  defaultMaxTurns;
+  lifecycle;
+  outputSchema;
+  observability;
+  guardrails;
+  middlewares;
+  memory;
+  constructor(options) {
+    const resolved = resolveAgentOptions(options);
+    this.id = normalizeAgentId(resolved.id);
+    this.name = resolved.name;
+    this.description = resolved.description;
+    this.model = resolved.model;
+    this.instructions = resolved.instructions;
+    this.context = snapshotAgentContext(resolved.context);
+    this.temperature = resolved.temperature;
+    this.maxTokens = resolved.maxTokens;
+    if (resolved.providerOptions !== void 0) {
+      assertJsonObject(resolved.providerOptions, "Agent providerOptions");
+    }
+    this.providerOptions = cloneFrozenPlainData(resolved.providerOptions);
+    assertCompletionControlsSupported(this.model, resolved.controls);
+    this.controls = cloneFrozenPlainData(resolved.controls);
+    this.retries = cloneFrozenPlainData(resolved.retries);
+    const preparedTools = prepareAgentTools(resolved);
+    this.mcpServers = preparedTools.mcpServers;
+    this.tools = preparedTools.tools;
+    registerAgentToolState(this, preparedTools.publicState, preparedTools.toolsByName);
+    this.toolChoice = cloneFrozenPlainData(resolved.toolChoice);
+    this.defaultMaxTurns = assertNonnegativeSafeInteger(
+      resolved.defaultMaxTurns ?? DEFAULT_MAX_TURNS,
+      "maxTurns"
+    );
+    this.lifecycle = resolved.lifecycle;
+    this.outputSchema = resolved.outputSchema;
+    registerAgentProviderOutputSchema(this, resolved.outputSchema);
+    this.observability = snapshotAgentObservability(resolved.observability);
+    this.guardrails = snapshotGuardrailPolicies(resolved.guardrails);
+    this.middlewares = Object.freeze([...resolved.middlewares ?? []]);
+    this.memory = snapshotAgentMemory(resolved.memory);
+  }
+  generate(options) {
+    return AgentRun.fromAgent(this, options).generate();
+  }
+  resume(continuation, response, settings = {}) {
+    return this.generate({ continuation, response, ...settings });
+  }
+  stream(options) {
+    const run = AgentRun.fromAgent(this, options);
+    if (!this.model.capabilities.streaming || !isStreamingCompletionModel(this.model)) {
+      throw new Error("This completion model does not support streaming");
+    }
+    return createAgentStream(run);
+  }
+  compactMemory(options) {
+    if (typeof options !== "object" || options === null || Array.isArray(options)) {
+      throw new TypeError("Manual memory compaction requires an options object.");
+    }
+    const scope = normalizeMemoryScope(options.session, "Manual memory compaction");
+    const memory = new AgentRunMemory(this, scope, []);
+    return memory.compact(
+      `manual-memory-compaction:${globalThis.crypto.randomUUID()}`,
+      options.abortSignal
+    );
+  }
+  asTool(options) {
+    return createAgentTool(this, options);
+  }
+  getTool(toolName) {
+    return getRegisteredAgentTool(this, toolName);
+  }
+  async callTool(toolName, args, context) {
+    const tool = this.getTool(toolName);
+    if (tool === void 0) {
+      throw new ToolNotFoundError(toolName);
+    }
+    return prepareToolCall(tool, args).call(context ?? {});
+  }
+};
+
+export {
+  Agent
+};
+//# sourceMappingURL=chunk-4S4OECPW.js.map

package/dist/chunk-4S4OECPW.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/agent/agent.ts"],"sourcesContent":["import { isStreamingCompletionModel } from \"../completion/generate-completion\";\nimport {\n  assertCompletionControlsSupported,\n  type CompletionControlValues,\n  type CompletionModel,\n  type CompletionModelControlsOf,\n  type JsonObject,\n  type ToolChoice,\n} from \"../completion/index\";\nimport type { GuardrailPolicy } from \"../guardrails\";\nimport { AgentRun } from \"../internal/agent-runtime/agent-run\";\nimport { AgentRunMemory } from \"../internal/agent-runtime/memory\";\nimport { normalizeMemoryScope } from \"../internal/agent-runtime/memory-scope\";\nimport { prepareToolCall } from \"../internal/agent-runtime/prepared-tool-call\";\nimport { assertNonnegativeSafeInteger } from \"../internal/agent-runtime/run-validation\";\nimport { assertJsonObject } from \"../internal/json-object\";\nimport type { McpServer } from \"../mcp\";\nimport type { MemoryCompactionResult } from \"../memory\";\nimport type { AgentObservabilityOptions } from \"../observability\";\nimport type { RetrySetting } from \"../retry\";\nimport type { ZodSchema } from \"../schema/zod-schema\";\nimport { ToolNotFoundError } from \"../tool/errors\";\nimport type { AgentMiddleware } from \"../tool/middleware\";\nimport type { AnyTool, NormalizedToolOutput, Tool, ToolCallContext } from \"../tool/tool\";\nimport { createAgentStream } from \"./agent-stream\";\nimport { createAgentTool } from \"./agent-tool\";\nimport { normalizeAgentId } from \"./ids\";\nimport type { AgentContinuation, AgentInteractionResponse } from \"./interactions\";\nimport type { AgentLifecycle } from \"./lifecycle\";\nimport { registerAgentProviderOutputSchema } from \"./output-schema\";\nimport { resolveAgentOptions } from \"./resolve-options\";\nimport type {\n  AgentMemoryCompactionOptions,\n  AgentOutcome,\n  AgentRunOptions,\n  AgentRunSettings,\n  AgentStream,\n} from \"./run-types\";\nimport {\n  cloneFrozenPlainData,\n  snapshotAgentContext,\n  snapshotAgentMemory,\n  snapshotAgentObservability,\n  snapshotGuardrailPolicies,\n} from \"./snapshot\";\nimport { prepareAgentTools } from \"./tool-catalog\";\nimport { getRegisteredAgentTool, registerAgentToolState } from \"./tool-state\";\nimport type { AgentContextInput, AgentMemory, AgentOptions, AgentToolOptions } from \"./types\";\n\nconst DEFAULT_MAX_TURNS = 20;\n\ntype RawResponseOf<Model> =\n  Model extends CompletionModel<infer RawResponse> ? RawResponse : unknown;\n\nexport class Agent<\n  Output = string,\n  M extends CompletionModel = CompletionModel,\n  ContextDocument = unknown,\n> {\n  readonly id: string;\n  readonly name: string | undefined;\n  readonly description: string | undefined;\n  readonly model: M;\n  readonly instructions: string | undefined;\n  readonly context: readonly AgentContextInput<ContextDocument>[];\n  readonly temperature: number | undefined;\n  readonly maxTokens: number | undefined;\n  readonly providerOptions: JsonObject | undefined;\n  readonly controls: CompletionControlValues<CompletionModelControlsOf<M>> | undefined;\n  readonly retries: RetrySetting | undefined;\n  readonly mcpServers: readonly McpServer[];\n  readonly tools: readonly AnyTool[];\n  readonly toolChoice: ToolChoice | undefined;\n  readonly defaultMaxTurns: number | undefined;\n  readonly lifecycle: AgentLifecycle<Output, RawResponseOf<M>> | undefined;\n  readonly outputSchema: ZodSchema<Output> | undefined;\n  readonly observability: AgentObservabilityOptions | undefined;\n  readonly guardrails: readonly GuardrailPolicy[];\n  readonly middlewares: readonly AgentMiddleware[];\n  readonly memory: AgentMemory | undefined;\n\n  constructor(options: AgentOptions<Output, M, ContextDocument>) {\n    const resolved = resolveAgentOptions(options);\n    this.id = normalizeAgentId(resolved.id);\n    this.name = resolved.name;\n    this.description = resolved.description;\n    this.model = resolved.model;\n    this.instructions = resolved.instructions;\n    this.context = snapshotAgentContext(resolved.context);\n    this.temperature = resolved.temperature;\n    this.maxTokens = resolved.maxTokens;\n    if (resolved.providerOptions !== undefined) {\n      assertJsonObject(resolved.providerOptions, \"Agent providerOptions\");\n    }\n    this.providerOptions = cloneFrozenPlainData(resolved.providerOptions);\n    assertCompletionControlsSupported(this.model, resolved.controls);\n    this.controls = cloneFrozenPlainData(resolved.controls);\n    this.retries = cloneFrozenPlainData(resolved.retries);\n\n    const preparedTools = prepareAgentTools(resolved);\n    this.mcpServers = preparedTools.mcpServers;\n    this.tools = preparedTools.tools;\n    registerAgentToolState(this, preparedTools.publicState, preparedTools.toolsByName);\n\n    this.toolChoice = cloneFrozenPlainData(resolved.toolChoice);\n    this.defaultMaxTurns = assertNonnegativeSafeInteger(\n      resolved.defaultMaxTurns ?? DEFAULT_MAX_TURNS,\n      \"maxTurns\",\n    );\n    this.lifecycle = resolved.lifecycle;\n    this.outputSchema = resolved.outputSchema;\n    registerAgentProviderOutputSchema(this, resolved.outputSchema);\n    this.observability = snapshotAgentObservability(resolved.observability);\n    this.guardrails = snapshotGuardrailPolicies(resolved.guardrails);\n    this.middlewares = Object.freeze([...(resolved.middlewares ?? [])]);\n    this.memory = snapshotAgentMemory(resolved.memory);\n  }\n\n  generate(\n    options: AgentRunOptions<Output, RawResponseOf<M>, CompletionModelControlsOf<M>>,\n  ): Promise<AgentOutcome<Output>> {\n    return AgentRun.fromAgent(this, options).generate();\n  }\n\n  resume(\n    continuation: AgentContinuation,\n    response: AgentInteractionResponse,\n    settings: AgentRunSettings<Output, RawResponseOf<M>, CompletionModelControlsOf<M>> = {},\n  ): Promise<AgentOutcome<Output>> {\n    return this.generate({ continuation, response, ...settings });\n  }\n\n  stream(\n    options: AgentRunOptions<Output, RawResponseOf<M>, CompletionModelControlsOf<M>>,\n  ): AgentStream<Output, RawResponseOf<M>> {\n    const run = AgentRun.fromAgent(this, options);\n    if (!this.model.capabilities.streaming || !isStreamingCompletionModel(this.model)) {\n      throw new Error(\"This completion model does not support streaming\");\n    }\n    return createAgentStream(run);\n  }\n\n  compactMemory(options: AgentMemoryCompactionOptions): Promise<MemoryCompactionResult> {\n    if (typeof options !== \"object\" || options === null || Array.isArray(options)) {\n      throw new TypeError(\"Manual memory compaction requires an options object.\");\n    }\n    const scope = normalizeMemoryScope(options.session, \"Manual memory compaction\");\n    const memory = new AgentRunMemory(this, scope, []);\n    return memory.compact(\n      `manual-memory-compaction:${globalThis.crypto.randomUUID()}`,\n      options.abortSignal,\n    );\n  }\n\n  asTool(options: AgentToolOptions): Tool<{ prompt: string }, Output> {\n    return createAgentTool(this, options);\n  }\n\n  getTool(toolName: string): AnyTool | undefined {\n    return getRegisteredAgentTool(this, toolName);\n  }\n\n  async callTool(\n    toolName: string,\n    args: string,\n    context?: ToolCallContext,\n  ): Promise<NormalizedToolOutput> {\n    const tool = this.getTool(toolName);\n    if (tool === undefined) {\n      throw new ToolNotFoundError(toolName);\n    }\n    return prepareToolCall(tool, args).call(context ?? {});\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-4UUIGAIX.js

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-4UUIGAIX.js.map

package/dist/chunk-4UUIGAIX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-53TPAXYR.js

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-53TPAXYR.js.map

package/dist/chunk-53TPAXYR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-54ZZJRP2.js

@@ -0,0 +1,57 @@
+import {
+  isJsonValue
+} from "./chunk-4C7AXYOM.js";
+
+// src/streaming/readable-stream.ts
+function toReadableStream(events, _options = {}) {
+  const encoder = new TextEncoder();
+  const iterator = events[Symbol.asyncIterator]();
+  return new ReadableStream({
+    async pull(controller) {
+      try {
+        const next = await iterator.next();
+        if (next.done === true) {
+          controller.close();
+          return;
+        }
+        controller.enqueue(encoder.encode(`${JSON.stringify(next.value)}
+`));
+      } catch (error) {
+        controller.enqueue(
+          encoder.encode(`${JSON.stringify({ type: "error", error: serializeError(error) })}
+`)
+        );
+        controller.close();
+      }
+    },
+    async cancel() {
+      await iterator.return?.();
+    }
+  });
+}
+function serializeError(error) {
+  if (error instanceof Error) {
+    const serialized = {
+      name: error.name,
+      message: error.message
+    };
+    const code = error.code;
+    if (code !== void 0) {
+      serialized.code = code;
+    }
+    const details = error.details;
+    if (details !== void 0) {
+      serialized.details = details;
+    }
+    return serialized;
+  }
+  if (isJsonValue(error)) {
+    return error;
+  }
+  return { message: String(error) };
+}
+
+export {
+  toReadableStream
+};
+//# sourceMappingURL=chunk-54ZZJRP2.js.map