@anvia/core 0.1.0

package/dist/chunk-IQBY2GCF.js

@@ -0,0 +1,1207 @@
+import {
+  toReadableStream
+} from "./chunk-XUUY2L2D.js";
+import {
+  ToolSet
+} from "./chunk-GNWMOSNR.js";
+import {
+  createTool,
+  toProviderJsonSchema
+} from "./chunk-B4QHQN5K.js";
+import {
+  CompletionRequestBuilder,
+  Message,
+  ToolContent,
+  Usage,
+  assertCompletionRequestSupported,
+  textFromAssistantContent
+} from "./chunk-CP47FBJV.js";
+
+// src/agent/agent.ts
+import { z } from "zod";
+
+// src/observability/group.ts
+async function startAgentRunObservers(registrations, args, failOnObserverError) {
+  const runObservers = [];
+  for (const registration of registrations) {
+    try {
+      const runObserver = await registration.observer.startRun(args);
+      if (runObserver !== void 0) {
+        runObservers.push(runObserver);
+      }
+    } catch (error) {
+      if (failOnObserverError || registration.failOnObserverError === true) {
+        throw error;
+      }
+    }
+  }
+  return new ActiveAgentRunObservers(runObservers, failOnObserverError);
+}
+var ActiveAgentRunObservers = class {
+  constructor(runObservers, failOnObserverError) {
+    this.runObservers = runObservers;
+    this.failOnObserverError = failOnObserverError;
+    this.trace = runObservers.find((observer) => observer.trace !== void 0)?.trace;
+  }
+  runObservers;
+  failOnObserverError;
+  trace;
+  async startGeneration(args) {
+    const generationObservers = [];
+    for (const runObserver of this.runObservers) {
+      if (runObserver.startGeneration === void 0) {
+        continue;
+      }
+      try {
+        const generationObserver = await runObserver.startGeneration(args);
+        if (generationObserver !== void 0) {
+          generationObservers.push(generationObserver);
+        }
+      } catch (error) {
+        this.handleError(error);
+      }
+    }
+    return new ActiveGenerationObservers(generationObservers, this.failOnObserverError);
+  }
+  async startTool(args) {
+    const toolObservers = [];
+    for (const runObserver of this.runObservers) {
+      if (runObserver.startTool === void 0) {
+        continue;
+      }
+      try {
+        const toolObserver = await runObserver.startTool(args);
+        if (toolObserver !== void 0) {
+          toolObservers.push(toolObserver);
+        }
+      } catch (error) {
+        this.handleError(error);
+      }
+    }
+    return new ActiveToolObservers(toolObservers, this.failOnObserverError);
+  }
+  async end(args) {
+    for (const runObserver of this.runObservers) {
+      try {
+        await runObserver.end(args);
+      } catch (error) {
+        this.handleError(error);
+      }
+    }
+  }
+  async error(args) {
+    for (const runObserver of this.runObservers) {
+      if (runObserver.error === void 0) {
+        continue;
+      }
+      try {
+        await runObserver.error(args);
+      } catch (error) {
+        this.handleError(error);
+      }
+    }
+  }
+  handleError(error) {
+    if (this.failOnObserverError) {
+      throw error;
+    }
+  }
+};
+var ActiveGenerationObservers = class {
+  constructor(generationObservers, failOnObserverError) {
+    this.generationObservers = generationObservers;
+    this.failOnObserverError = failOnObserverError;
+  }
+  generationObservers;
+  failOnObserverError;
+  async end(args) {
+    for (const observer of this.generationObservers) {
+      try {
+        await observer.end(args);
+      } catch (error) {
+        this.handleError(error);
+      }
+    }
+  }
+  async error(args) {
+    for (const observer of this.generationObservers) {
+      if (observer.error === void 0) {
+        continue;
+      }
+      try {
+        await observer.error(args);
+      } catch (error) {
+        this.handleError(error);
+      }
+    }
+  }
+  handleError(error) {
+    if (this.failOnObserverError) {
+      throw error;
+    }
+  }
+};
+var ActiveToolObservers = class {
+  constructor(toolObservers, failOnObserverError) {
+    this.toolObservers = toolObservers;
+    this.failOnObserverError = failOnObserverError;
+  }
+  toolObservers;
+  failOnObserverError;
+  async end(args) {
+    for (const observer of this.toolObservers) {
+      try {
+        await observer.end(args);
+      } catch (error) {
+        this.handleError(error);
+      }
+    }
+  }
+  async error(args) {
+    for (const observer of this.toolObservers) {
+      if (observer.error === void 0) {
+        continue;
+      }
+      try {
+        await observer.error(args);
+      } catch (error) {
+        this.handleError(error);
+      }
+    }
+  }
+  handleError(error) {
+    if (this.failOnObserverError) {
+      throw error;
+    }
+  }
+};
+
+// src/agent/errors.ts
+var MaxTurnsError = class extends Error {
+  constructor(maxTurns, chatHistory, prompt) {
+    super(`Reached max turn limit: ${maxTurns}`);
+    this.maxTurns = maxTurns;
+    this.chatHistory = chatHistory;
+    this.prompt = prompt;
+    this.name = "MaxTurnsError";
+  }
+  maxTurns;
+  chatHistory;
+  prompt;
+};
+var PromptCancelledError = class extends Error {
+  constructor(chatHistory, reason) {
+    super(`Prompt cancelled: ${reason}`);
+    this.chatHistory = chatHistory;
+    this.reason = reason;
+    this.name = "PromptCancelledError";
+  }
+  chatHistory;
+  reason;
+};
+
+// src/agent/hooks.ts
+function createHook(hook) {
+  return hook;
+}
+function cancelPrompt(reason) {
+  return { type: "terminate", reason };
+}
+function skipTool(reason) {
+  return { type: "skip", reason };
+}
+var runControl = {
+  continue() {
+    return { type: "continue" };
+  },
+  cancel(reason) {
+    return cancelPrompt(reason);
+  }
+};
+var toolCallControl = {
+  run() {
+    return { type: "continue" };
+  },
+  skip(reason) {
+    return skipTool(reason);
+  },
+  cancel(reason) {
+    return { type: "terminate", reason };
+  }
+};
+
+// src/agent/utils.ts
+function isStreamingCompletionModel(model) {
+  return "streamCompletion" in model && typeof model.streamCompletion === "function";
+}
+function extractRagText(message) {
+  if (message.role === "user") {
+    return message.content.flatMap((item) => item.type === "text" ? [item.text] : []).join("\n");
+  }
+  if (message.role === "tool") {
+    return message.content.flatMap((item) => item.content.flatMap((part) => part.type === "text" ? [part.text] : [])).join("\n");
+  }
+  return void 0;
+}
+function parseJsonValue(text) {
+  if (text.trim().length === 0) {
+    return {};
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+async function mapWithConcurrency(items, concurrency, mapper) {
+  const results = [];
+  let next = 0;
+  async function worker() {
+    while (next < items.length) {
+      const index = next;
+      next += 1;
+      const item = items[index];
+      if (item !== void 0) {
+        results[index] = await mapper(item);
+      }
+    }
+  }
+  const workerCount = Math.min(concurrency, items.length);
+  await Promise.all(Array.from({ length: workerCount }, () => worker()));
+  return results;
+}
+
+// src/agent/stream-accumulator.ts
+var CompletionStreamAccumulator = class _CompletionStreamAccumulator {
+  static defaultReasoningKey = "reasoning";
+  text = "";
+  reasoningById = /* @__PURE__ */ new Map();
+  reasoningOrder = [];
+  toolCalls = /* @__PURE__ */ new Map();
+  toolCallOrder = [];
+  finalResponse;
+  messageId;
+  accept(event) {
+    if (event.type === "text_delta") {
+      this.text += event.delta;
+      return { type: "text_delta", delta: event.delta };
+    }
+    if (event.type === "reasoning_delta") {
+      const key = event.id ?? _CompletionStreamAccumulator.defaultReasoningKey;
+      const existing = this.reasoningById.get(key);
+      const reasoning = existing ?? { text: "" };
+      if (!existing) {
+        this.reasoningOrder.push(key);
+      }
+      this.appendReasoning(reasoning, event);
+      this.reasoningById.set(key, reasoning);
+      return reasoningDeltaEvent(event);
+    }
+    if (event.type === "tool_call_delta") {
+      const existing = this.toolCalls.get(event.id);
+      const toolCall = existing ?? {
+        id: event.id,
+        name: "",
+        argumentsText: ""
+      };
+      if (!existing) {
+        this.toolCallOrder.push(event.id);
+      }
+      if (event.callId !== void 0) toolCall.callId = event.callId;
+      if (event.name !== void 0) toolCall.name = event.name;
+      if (event.signature !== void 0) toolCall.signature = event.signature;
+      if (event.argumentsDelta !== void 0) {
+        toolCall.argumentsText += event.argumentsDelta;
+      }
+      this.toolCalls.set(event.id, toolCall);
+      return void 0;
+    }
+    if (event.type === "tool_call") {
+      this.upsertToolCall(event.toolCall);
+      return void 0;
+    }
+    if (event.type === "message_id") {
+      this.messageId = event.id;
+      return void 0;
+    }
+    if (event.type === "final") {
+      this.finalResponse = event.response;
+      return void 0;
+    }
+    return void 0;
+  }
+  response() {
+    if (this.finalResponse !== void 0) {
+      if (this.finalResponse.choice.length === 0) {
+        const response = {
+          ...this.buildAccumulatedResponse(),
+          usage: this.finalResponse.usage,
+          rawResponse: this.finalResponse.rawResponse
+        };
+        if (this.finalResponse.messageId !== void 0) {
+          response.messageId = this.finalResponse.messageId;
+        }
+        return response;
+      }
+      return this.finalResponse;
+    }
+    return this.buildAccumulatedResponse();
+  }
+  buildAccumulatedResponse() {
+    const choice = [];
+    if (this.text.length > 0) {
+      choice.push({ type: "text", text: this.text });
+    }
+    for (const key of this.reasoningOrder) {
+      const reasoning = this.reasoningById.get(key) ?? { text: "" };
+      const id = key === _CompletionStreamAccumulator.defaultReasoningKey ? void 0 : key;
+      const content = reasoning.content === void 0 ? { type: "reasoning", text: reasoning.text } : { type: "reasoning", text: reasoning.text, content: reasoning.content };
+      choice.push(id === void 0 ? content : { ...content, id });
+    }
+    for (const id of this.toolCallOrder) {
+      const toolCall = this.toolCalls.get(id);
+      if (toolCall !== void 0) {
+        const content = {
+          type: "tool_call",
+          id: toolCall.id,
+          function: {
+            name: toolCall.name,
+            arguments: parseJsonValue(toolCall.argumentsText)
+          }
+        };
+        if (toolCall.callId !== void 0) {
+          content.callId = toolCall.callId;
+        }
+        if (toolCall.signature !== void 0) {
+          content.signature = toolCall.signature;
+        }
+        choice.push(content);
+      }
+    }
+    const response = {
+      choice,
+      usage: Usage.empty(),
+      rawResponse: void 0
+    };
+    if (this.messageId !== void 0) {
+      response.messageId = this.messageId;
+    }
+    return response;
+  }
+  upsertToolCall(toolCall) {
+    if (!this.toolCalls.has(toolCall.id)) {
+      this.toolCallOrder.push(toolCall.id);
+    }
+    const partial = {
+      id: toolCall.id,
+      name: toolCall.function.name,
+      argumentsText: JSON.stringify(toolCall.function.arguments ?? {})
+    };
+    if (toolCall.callId !== void 0) {
+      partial.callId = toolCall.callId;
+    }
+    if (toolCall.signature !== void 0) {
+      partial.signature = toolCall.signature;
+    }
+    this.toolCalls.set(toolCall.id, partial);
+  }
+  appendReasoning(reasoning, event) {
+    const contentType = event.contentType ?? "text";
+    if (contentType === "text" || contentType === "summary") {
+      reasoning.text += event.delta;
+    }
+    if (event.contentType === void 0 && event.signature === void 0) {
+      return;
+    }
+    reasoning.content ??= [];
+    const last = reasoning.content.at(-1);
+    if (contentType === "text") {
+      if (last?.type === "text") {
+        last.text += event.delta;
+        if (event.signature !== void 0) {
+          last.signature = event.signature;
+        }
+      } else {
+        reasoning.content.push(
+          event.signature === void 0 ? { type: "text", text: event.delta } : { type: "text", text: event.delta, signature: event.signature }
+        );
+      }
+      return;
+    }
+    if (contentType === "summary") {
+      if (last?.type === "summary") {
+        last.text += event.delta;
+      } else {
+        reasoning.content.push({ type: "summary", text: event.delta });
+      }
+      return;
+    }
+    if (contentType === "encrypted") {
+      reasoning.content.push({ type: "encrypted", data: event.delta });
+      return;
+    }
+    reasoning.content.push({ type: "redacted", data: event.delta });
+  }
+};
+function reasoningDeltaEvent(event) {
+  const mapped = { type: "reasoning_delta", delta: event.delta };
+  if (event.id !== void 0) mapped.id = event.id;
+  if (event.contentType !== void 0) mapped.contentType = event.contentType;
+  if (event.signature !== void 0) mapped.signature = event.signature;
+  return mapped;
+}
+
+// src/agent/request.ts
+var PromptRequest = class _PromptRequest {
+  constructor(agent, promptMessage) {
+    this.agent = agent;
+    this.promptMessage = promptMessage;
+    this.maxTurnCount = agent.defaultMaxTurns ?? 0;
+    this.activeHook = agent.hook;
+  }
+  agent;
+  promptMessage;
+  chatHistory;
+  maxTurnCount;
+  activeHook;
+  concurrency = 1;
+  traceOptions;
+  static fromAgent(agent, prompt) {
+    return new _PromptRequest(agent, typeof prompt === "string" ? Message.user(prompt) : prompt);
+  }
+  withHistory(history) {
+    this.chatHistory = history;
+    return this;
+  }
+  maxTurns(maxTurns) {
+    this.maxTurnCount = maxTurns;
+    return this;
+  }
+  requestHook(hook) {
+    this.activeHook = hook;
+    return this;
+  }
+  withToolConcurrency(concurrency) {
+    this.concurrency = Math.max(1, concurrency);
+    return this;
+  }
+  withTrace(trace) {
+    this.traceOptions = trace;
+    return this;
+  }
+  async send() {
+    const newMessages = [this.promptMessage];
+    let usage = Usage.empty();
+    let currentTurns = 0;
+    let lastPrompt = this.promptMessage;
+    const runObservers = await this.startRunObservers();
+    try {
+      while (currentTurns <= this.maxTurnCount + 1) {
+        const prompt = newMessages.at(-1);
+        if (prompt === void 0) {
+          throw new Error("PromptRequest requires at least one message");
+        }
+        lastPrompt = prompt;
+        currentTurns += 1;
+        const historyForRequest = [...this.chatHistory ?? [], ...newMessages.slice(0, -1)];
+        await this.runCompletionCallHook(prompt, historyForRequest, newMessages);
+        const ragText = extractRagText(prompt);
+        const dynamicContext = await this.fetchDynamicContext(ragText);
+        const toolDefs = await this.fetchToolDefinitions(ragText);
+        const request = new CompletionRequestBuilder(this.agent.model, prompt).instructions(this.agent.instructions).messages(historyForRequest).documents([...this.agent.staticContext, ...dynamicContext]).tools(toolDefs).temperature(this.agent.temperature).maxTokens(this.agent.maxTokens).additionalParams(this.agent.additionalParams).toolChoice(this.agent.toolChoice).outputSchema(this.agent.outputSchema).build();
+        const response = await this.runCompletion(request, currentTurns, runObservers);
+        usage = Usage.add(usage, response.usage);
+        await this.runCompletionResponseHook(prompt, response, newMessages);
+        newMessages.push(Message.assistant(response.choice, response.messageId));
+        const toolCalls = response.choice.filter(
+          (item) => item.type === "tool_call"
+        );
+        if (toolCalls.length === 0) {
+          const result = {
+            output: textFromAssistantContent(response.choice),
+            usage,
+            messages: [...newMessages],
+            trace: runObservers.trace
+          };
+          await runObservers.end(result);
+          return result;
+        }
+        const toolResults = await this.executeToolCalls(toolCalls, newMessages, void 0, {
+          turn: currentTurns,
+          runObservers
+        });
+        newMessages.push(Message.tool(toolResults));
+      }
+      throw new MaxTurnsError(
+        this.maxTurnCount,
+        [...this.chatHistory ?? [], ...newMessages],
+        lastPrompt
+      );
+    } catch (error) {
+      await runObservers.error({ error, usage, messages: [...newMessages] });
+      throw error;
+    }
+  }
+  async *stream() {
+    if (!this.agent.model.capabilities.streaming || !isStreamingCompletionModel(this.agent.model)) {
+      throw new Error("This completion model does not support streaming");
+    }
+    const newMessages = [this.promptMessage];
+    let usage = Usage.empty();
+    let currentTurns = 0;
+    let lastPrompt = this.promptMessage;
+    const runObservers = await this.startRunObservers();
+    try {
+      while (currentTurns <= this.maxTurnCount + 1) {
+        const prompt = newMessages.at(-1);
+        if (prompt === void 0) {
+          throw new Error("PromptRequest requires at least one message");
+        }
+        lastPrompt = prompt;
+        currentTurns += 1;
+        const historyForRequest = [...this.chatHistory ?? [], ...newMessages.slice(0, -1)];
+        yield {
+          type: "turn_start",
+          turn: currentTurns,
+          prompt,
+          history: historyForRequest
+        };
+        await this.runCompletionCallHook(prompt, historyForRequest, newMessages);
+        const ragText = extractRagText(prompt);
+        const dynamicContext = await this.fetchDynamicContext(ragText);
+        const toolDefs = await this.fetchToolDefinitions(ragText);
+        const request = new CompletionRequestBuilder(this.agent.model, prompt).instructions(this.agent.instructions).messages(historyForRequest).documents([...this.agent.staticContext, ...dynamicContext]).tools(toolDefs).temperature(this.agent.temperature).maxTokens(this.agent.maxTokens).additionalParams(this.agent.additionalParams).toolChoice(this.agent.toolChoice).outputSchema(this.agent.outputSchema).build();
+        assertCompletionRequestSupported(this.agent.model, request, { streaming: true });
+        const generationObservers = await runObservers.startGeneration({
+          turn: currentTurns,
+          request
+        });
+        const accumulator = new CompletionStreamAccumulator();
+        const generationStartedAt = Date.now();
+        let firstDeltaMs;
+        try {
+          for await (const event of this.agent.model.streamCompletion(request)) {
+            if (firstDeltaMs === void 0 && isGenerationDeltaEvent(event.type)) {
+              firstDeltaMs = Date.now() - generationStartedAt;
+            }
+            const mapped = accumulator.accept(event);
+            if (event.type === "error") {
+              throw event.error;
+            }
+            if (mapped !== void 0) {
+              yield addTurn(currentTurns, mapped);
+            }
+          }
+        } catch (error) {
+          await generationObservers.error({ turn: currentTurns, error });
+          throw error;
+        }
+        const response = accumulator.response();
+        await generationObservers.end({
+          turn: currentTurns,
+          response,
+          ...firstDeltaMs === void 0 ? {} : { firstDeltaMs }
+        });
+        usage = Usage.add(usage, response.usage);
+        await this.runCompletionResponseHook(prompt, response, newMessages);
+        newMessages.push(Message.assistant(response.choice, response.messageId));
+        const toolCalls = response.choice.filter(
+          (item) => item.type === "tool_call"
+        );
+        for (const toolCall of toolCalls) {
+          yield { type: "tool_call", turn: currentTurns, toolCall };
+        }
+        yield { type: "turn_end", turn: currentTurns, response };
+        if (toolCalls.length === 0) {
+          const output = textFromAssistantContent(response.choice);
+          yield {
+            type: "final",
+            output,
+            usage,
+            messages: [...newMessages],
+            trace: runObservers.trace
+          };
+          await runObservers.end({ output, usage, messages: [...newMessages] });
+          return;
+        }
+        const toolResultEvents = createAsyncQueue();
+        const toolResultsPromise = this.executeToolCalls(
+          toolCalls,
+          newMessages,
+          (result) => {
+            toolResultEvents.enqueue(result);
+          },
+          {
+            turn: currentTurns,
+            runObservers
+          }
+        );
+        toolResultsPromise.then(
+          () => toolResultEvents.close(),
+          (error) => toolResultEvents.throw(error)
+        );
+        for await (const result of toolResultEvents) {
+          yield { type: "tool_result", turn: currentTurns, ...result };
+        }
+        const toolResults = await toolResultsPromise;
+        newMessages.push(Message.tool(toolResults));
+      }
+      throw new MaxTurnsError(
+        this.maxTurnCount,
+        [...this.chatHistory ?? [], ...newMessages],
+        lastPrompt
+      );
+    } catch (error) {
+      await runObservers.error({ error, usage, messages: [...newMessages] });
+      yield { type: "error", error };
+      throw error;
+    }
+  }
+  readableStream() {
+    return toReadableStream(this.stream());
+  }
+  async runCompletion(request, turn, runObservers) {
+    assertCompletionRequestSupported(this.agent.model, request);
+    const generationObservers = await runObservers.startGeneration({ turn, request });
+    try {
+      const response = await this.agent.model.completion(request);
+      await generationObservers.end({ turn, response });
+      return response;
+    } catch (error) {
+      await generationObservers.error({ turn, error });
+      throw error;
+    }
+  }
+  async executeToolCalls(toolCalls, newMessages, onResult, observation) {
+    return mapWithConcurrency(toolCalls, this.concurrency, async (toolCall) => {
+      const args = JSON.stringify(toolCall.function.arguments ?? {});
+      const internalCallId = globalThis.crypto.randomUUID();
+      const hookArgs = {
+        toolName: toolCall.function.name,
+        internalCallId,
+        args
+      };
+      if (toolCall.callId !== void 0) {
+        hookArgs.toolCallId = toolCall.callId;
+      }
+      const toolObservers = await observation?.runObservers.startTool({
+        turn: observation.turn,
+        toolCall,
+        toolName: toolCall.function.name,
+        internalCallId,
+        args,
+        toolCallId: toolCall.callId
+      });
+      const callAction = await this.activeHook?.onToolCall?.({
+        ...hookArgs,
+        tool: toolCallControl
+      });
+      if (callAction?.type === "terminate") {
+        await this.recordToolError(
+          toolObservers,
+          observation?.turn,
+          toolCall,
+          internalCallId,
+          args,
+          callAction.reason
+        );
+        throw this.cancelled(newMessages, callAction.reason);
+      }
+      let output;
+      let skipped = false;
+      if (callAction?.type === "skip") {
+        output = callAction.reason;
+        skipped = true;
+      } else {
+        try {
+          output = await this.agent.callTool(toolCall.function.name, args);
+        } catch (error) {
+          output = error instanceof Error ? error.toString() : String(error);
+        }
+      }
+      const resultAction = await this.activeHook?.onToolResult?.({
+        ...hookArgs,
+        result: output,
+        run: runControl
+      });
+      await toolObservers?.end({
+        turn: observation?.turn ?? 0,
+        toolCall,
+        toolName: toolCall.function.name,
+        internalCallId,
+        args,
+        result: output,
+        skipped,
+        toolCallId: toolCall.callId
+      });
+      if (resultAction?.type === "terminate") {
+        throw this.cancelled(newMessages, resultAction.reason);
+      }
+      const resultPayload = {
+        toolName: toolCall.function.name,
+        internalCallId,
+        args,
+        result: output
+      };
+      if (toolCall.callId !== void 0) {
+        resultPayload.toolCallId = toolCall.callId;
+      }
+      onResult?.(resultPayload);
+      return ToolContent.toolResult(toolCall.id, output, toolCall.callId);
+    });
+  }
+  async startRunObservers() {
+    const failOnObserverError = this.traceOptions?.failOnObserverError === true || this.agent.observers.some((registration) => registration.failOnObserverError === true);
+    return startAgentRunObservers(
+      this.agent.observers,
+      {
+        agentName: this.agent.name,
+        agentDescription: this.agent.description,
+        instructions: this.agent.instructions,
+        trace: this.traceOptions,
+        prompt: this.promptMessage,
+        history: this.chatHistory ?? [],
+        maxTurns: this.maxTurnCount
+      },
+      failOnObserverError
+    );
+  }
+  async fetchDynamicContext(ragText) {
+    if (ragText === void 0 || ragText.length === 0 || this.agent.dynamicContexts.length === 0) {
+      return [];
+    }
+    const documents = [];
+    for (const registration of this.agent.dynamicContexts) {
+      const results = await registration.index.search({
+        query: ragText,
+        topK: registration.options.topK,
+        threshold: registration.options.threshold,
+        filter: registration.options.filter
+      });
+      for (const result of results) {
+        const formatted = registration.options.format?.(result);
+        if (formatted !== void 0) {
+          documents.push(formatted);
+        } else {
+          const metadata = formatMetadata(result.metadata);
+          documents.push({
+            id: result.id,
+            text: typeof result.document === "string" ? result.document : JSON.stringify(result.document, null, 2),
+            ...metadata === void 0 ? {} : { additionalProps: metadata }
+          });
+        }
+      }
+    }
+    return documents;
+  }
+  async fetchToolDefinitions(ragText) {
+    const staticDefinitions = await this.agent.toolSet.getToolDefinitions(ragText);
+    if (ragText === void 0 || ragText.length === 0 || this.agent.dynamicTools.length === 0) {
+      return staticDefinitions;
+    }
+    const definitions = [...staticDefinitions];
+    const names = new Set(staticDefinitions.map((definition) => definition.name));
+    for (const registration of this.agent.dynamicTools) {
+      const results = await registration.index.search({
+        query: ragText,
+        topK: registration.options.topK,
+        threshold: registration.options.threshold,
+        filter: registration.options.filter
+      });
+      for (const result of results) {
+        if (names.has(result.document.toolName)) {
+          continue;
+        }
+        names.add(result.document.toolName);
+        definitions.push(result.document.definition);
+      }
+    }
+    return definitions;
+  }
+  async recordToolError(toolObservers, turn, toolCall, internalCallId, args, error) {
+    await toolObservers?.error({
+      turn: turn ?? 0,
+      toolCall,
+      toolName: toolCall.function.name,
+      internalCallId,
+      args,
+      error,
+      toolCallId: toolCall.callId
+    });
+  }
+  async runCompletionCallHook(prompt, history, newMessages) {
+    const action = await this.activeHook?.onCompletionCall?.({
+      prompt,
+      history,
+      run: runControl
+    });
+    if (action?.type === "terminate") {
+      throw this.cancelled(newMessages, action.reason);
+    }
+  }
+  async runCompletionResponseHook(prompt, response, newMessages) {
+    const action = await this.activeHook?.onCompletionResponse?.({
+      prompt,
+      response,
+      run: runControl
+    });
+    if (action?.type === "terminate") {
+      throw this.cancelled(newMessages, action.reason);
+    }
+  }
+  cancelled(newMessages, reason) {
+    return new PromptCancelledError([...this.chatHistory ?? [], ...newMessages], reason);
+  }
+};
+function createAsyncQueue() {
+  const values = [];
+  const waiters = [];
+  let closed = false;
+  let error;
+  function flush() {
+    while (waiters.length > 0 && values.length > 0) {
+      const waiter = waiters.shift();
+      const value = values.shift();
+      if (waiter !== void 0) {
+        waiter.resolve({ value, done: false });
+      }
+    }
+    if (values.length > 0 || waiters.length === 0 || !closed) {
+      return;
+    }
+    while (waiters.length > 0) {
+      const waiter = waiters.shift();
+      if (waiter === void 0) {
+        continue;
+      }
+      if (error !== void 0) {
+        waiter.reject(error);
+      } else {
+        waiter.resolve({ value: void 0, done: true });
+      }
+    }
+  }
+  return {
+    enqueue(value) {
+      if (closed) {
+        return;
+      }
+      values.push(value);
+      flush();
+    },
+    close() {
+      closed = true;
+      flush();
+    },
+    throw(thrown) {
+      closed = true;
+      error = thrown;
+      flush();
+    },
+    [Symbol.asyncIterator]() {
+      return {
+        next() {
+          if (values.length > 0) {
+            const value = values.shift();
+            return Promise.resolve({ value, done: false });
+          }
+          if (error !== void 0) {
+            return Promise.reject(error);
+          }
+          if (closed) {
+            return Promise.resolve({ value: void 0, done: true });
+          }
+          return new Promise((resolve, reject) => {
+            waiters.push({ resolve, reject });
+          });
+        }
+      };
+    }
+  };
+}
+function addTurn(turn, event) {
+  if (event.type === "text_delta") {
+    return { type: "text_delta", turn, delta: event.delta };
+  }
+  if (event.type === "reasoning_delta") {
+    const mapped = { type: "reasoning_delta", turn, delta: event.delta };
+    if (event.id !== void 0) mapped.id = event.id;
+    if (event.contentType !== void 0) mapped.contentType = event.contentType;
+    if (event.signature !== void 0) mapped.signature = event.signature;
+    return mapped;
+  }
+  return { type: "tool_call", turn, toolCall: event.toolCall };
+}
+function isGenerationDeltaEvent(type) {
+  return type === "text_delta" || type === "reasoning_delta" || type === "tool_call_delta" || type === "tool_call";
+}
+function formatMetadata(metadata) {
+  if (metadata === void 0) {
+    return void 0;
+  }
+  return Object.fromEntries(Object.entries(metadata).map(([key, value]) => [key, String(value)]));
+}
+
+// src/agent/agent.ts
+var DEFAULT_MAX_TURNS = 20;
+var Agent = class {
+  id;
+  name;
+  description;
+  model;
+  instructions;
+  staticContext;
+  temperature;
+  maxTokens;
+  additionalParams;
+  toolSet;
+  toolChoice;
+  defaultMaxTurns;
+  hook;
+  outputSchema;
+  observers;
+  dynamicContexts;
+  dynamicTools;
+  constructor(options) {
+    this.id = normalizeAgentId(options.id);
+    this.name = options.name;
+    this.description = options.description;
+    this.model = options.model;
+    this.instructions = options.instructions;
+    this.staticContext = options.staticContext ?? [];
+    this.temperature = options.temperature;
+    this.maxTokens = options.maxTokens;
+    this.additionalParams = options.additionalParams;
+    this.toolSet = options.toolSet ?? new ToolSet();
+    this.toolChoice = options.toolChoice;
+    this.defaultMaxTurns = options.defaultMaxTurns ?? DEFAULT_MAX_TURNS;
+    this.hook = options.hook;
+    this.outputSchema = options.outputSchema;
+    this.observers = options.observers ?? [];
+    this.dynamicContexts = options.dynamicContexts ?? [];
+    this.dynamicTools = options.dynamicTools ?? [];
+  }
+  prompt(prompt) {
+    return PromptRequest.fromAgent(this, prompt);
+  }
+  asTool(options) {
+    const description = options.description ?? this.description ?? `Prompt the ${options.name} agent.`;
+    return createTool({
+      name: options.name,
+      description,
+      input: z.object({
+        prompt: z.string().describe("The prompt to send to the agent.")
+      }),
+      output: z.string(),
+      execute: async ({ prompt }) => {
+        const request = this.prompt(prompt);
+        const response = options.maxTurns === void 0 ? await request.send() : await request.maxTurns(options.maxTurns).send();
+        return response.output;
+      }
+    });
+  }
+  getTool(toolName) {
+    const staticTool = this.toolSet.get(toolName);
+    if (staticTool !== void 0) {
+      return staticTool;
+    }
+    for (const registration of this.dynamicTools) {
+      const dynamicTool = dynamicToolSetFromIndex(registration.index)?.get(toolName);
+      if (dynamicTool !== void 0) {
+        return dynamicTool;
+      }
+    }
+    return void 0;
+  }
+  async callTool(toolName, args) {
+    if (this.toolSet.contains(toolName)) {
+      return this.toolSet.call(toolName, args);
+    }
+    for (const registration of this.dynamicTools) {
+      const toolSet = dynamicToolSetFromIndex(registration.index);
+      if (toolSet?.contains(toolName)) {
+        return toolSet.call(toolName, args);
+      }
+    }
+    return this.toolSet.call(toolName, args);
+  }
+};
+function dynamicToolSetFromIndex(index) {
+  const maybeIndex = index;
+  return maybeIndex.toolSet instanceof ToolSet ? maybeIndex.toolSet : void 0;
+}
+function normalizeAgentId(id) {
+  if (typeof id !== "string") {
+    throw new TypeError("Agent id must be a string.");
+  }
+  const normalized = id.trim();
+  if (normalized.length === 0) {
+    throw new TypeError("Agent id must be a non-empty string.");
+  }
+  return normalized;
+}
+
+// src/agent/builder.ts
+var AgentBuilder = class {
+  constructor(agentId, completionModel) {
+    this.completionModel = completionModel;
+    this.agentId = normalizeAgentId2(agentId);
+  }
+  completionModel;
+  agentId;
+  agentName;
+  agentDescription;
+  instructionBlocks = [];
+  contextDocs = [];
+  temp;
+  maxTokenCount;
+  params;
+  choice;
+  turns;
+  requestHook;
+  schema;
+  skillInstructionBlocks = [];
+  observerRegistrations = [];
+  dynamicContextRegistrations = [];
+  dynamicToolRegistrations = [];
+  activeToolSet = new ToolSet();
+  name(name) {
+    this.agentName = name;
+    return this;
+  }
+  description(description) {
+    this.agentDescription = description;
+    return this;
+  }
+  instructions(instructions) {
+    if (instructions.length > 0) {
+      this.instructionBlocks.push(instructions);
+    }
+    return this;
+  }
+  context(text, id = `static_doc_${this.contextDocs.length}`) {
+    this.contextDocs.push({ id, text });
+    return this;
+  }
+  dynamicContext(index, options) {
+    this.dynamicContextRegistrations.push({ index, options });
+    return this;
+  }
+  dynamicTools(index, options) {
+    this.dynamicToolRegistrations.push({ index, options });
+    return this;
+  }
+  tool(tool) {
+    this.activeToolSet.addTool(tool);
+    return this;
+  }
+  tools(tools) {
+    this.activeToolSet.addTools(tools);
+    return this;
+  }
+  mcp(servers) {
+    for (const server of servers) {
+      this.activeToolSet.addTools(server.tools);
+    }
+    return this;
+  }
+  skills(skillSet) {
+    if (skillSet.instructions.length > 0) {
+      this.skillInstructionBlocks.push(skillSet.instructions);
+    }
+    this.activeToolSet.addTools(skillSet.tools);
+    return this;
+  }
+  useToolSet(toolSet) {
+    toolSet.addTools(this.activeToolSet);
+    this.activeToolSet = toolSet;
+    return this;
+  }
+  temperature(temperature) {
+    this.temp = temperature;
+    return this;
+  }
+  maxTokens(maxTokens) {
+    this.maxTokenCount = maxTokens;
+    return this;
+  }
+  additionalParams(params) {
+    this.params = params;
+    return this;
+  }
+  toolChoice(toolChoice) {
+    this.choice = toolChoice;
+    return this;
+  }
+  defaultMaxTurns(defaultMaxTurns) {
+    this.turns = defaultMaxTurns;
+    return this;
+  }
+  hook(hook) {
+    this.requestHook = hook;
+    return this;
+  }
+  observe(observer, options = {}) {
+    this.observerRegistrations.push({
+      observer,
+      failOnObserverError: options.failOnObserverError
+    });
+    return this;
+  }
+  outputSchema(schema) {
+    this.schema = toProviderJsonSchema(schema);
+    return this;
+  }
+  build() {
+    return new Agent({
+      id: this.agentId,
+      name: this.agentName,
+      description: this.agentDescription,
+      model: this.completionModel,
+      instructions: this.buildInstructions(),
+      staticContext: this.contextDocs,
+      temperature: this.temp,
+      maxTokens: this.maxTokenCount,
+      additionalParams: this.params,
+      toolSet: this.activeToolSet,
+      toolChoice: this.choice,
+      defaultMaxTurns: this.turns,
+      hook: this.requestHook,
+      outputSchema: this.schema,
+      observers: this.observerRegistrations,
+      dynamicContexts: this.dynamicContextRegistrations,
+      dynamicTools: this.dynamicToolRegistrations
+    });
+  }
+  buildInstructions() {
+    const parts = [...this.instructionBlocks, ...this.skillInstructionBlocks].filter(
+      (part) => part !== void 0 && part.length > 0
+    );
+    return parts.length === 0 ? void 0 : parts.join("\n\n");
+  }
+};
+function normalizeAgentId2(id) {
+  if (typeof id !== "string") {
+    throw new TypeError("Agent id must be a string.");
+  }
+  const normalized = id.trim();
+  if (normalized.length === 0) {
+    throw new TypeError("Agent id must be a non-empty string.");
+  }
+  return normalized;
+}
+
+export {
+  MaxTurnsError,
+  PromptCancelledError,
+  createHook,
+  cancelPrompt,
+  skipTool,
+  runControl,
+  toolCallControl,
+  PromptRequest,
+  DEFAULT_MAX_TURNS,
+  Agent,
+  AgentBuilder
+};
+//# sourceMappingURL=chunk-IQBY2GCF.js.map