@anvia/core 0.11.1 → 0.11.2

package/dist/{chunk-IFQVPV32.js → chunk-SISUMRUX.js}

@@ -2,19 +2,12 @@ import {
   toReadableStream
 } from "./chunk-XUUY2L2D.js";
 import {
-  isSkillTool
-} from "./chunk-YK4WAAS4.js";
-import {
-  ToolSet,
   parseToolArgs,
   toolResultContentToText
-} from "./chunk-BVGDCFQW.js";
-import {
-  createTool
-} from "./chunk-T22FYPE2.js";
+} from "./chunk-X3SWV6W6.js";
 import {
-  compact
-} from "./chunk-MMHG7WAM.js";
+  mapWithConcurrency
+} from "./chunk-OIMLU4SF.js";
 import {
   CompletionRequestBuilder,
   isStreamingCompletionModel
@@ -27,8 +20,12 @@ import {
   textFromAssistantContent
 } from "./chunk-WJO6NVE2.js";
 import {
-  mapWithConcurrency
-} from "./chunk-OIMLU4SF.js";
+  runControl,
+  toolCallControl
+} from "./chunk-NPZDYOE6.js";
+import {
+  compact
+} from "./chunk-MMHG7WAM.js";
 
 // src/request/errors.ts
 var MaxTurnsError = class extends Error {
@@ -62,50 +59,75 @@ var ToolApprovalRequiredError = class extends Error {
   request;
 };
 
-// src/hooks/index.ts
-function createHook(hook) {
-  return hook;
-}
-function cancelPrompt(reason) {
-  return { type: "terminate", reason };
-}
-function skipTool(reason) {
-  return { type: "skip", reason };
-}
-function requestToolApproval(options = {}) {
-  return compact({
-    type: "approval_request",
-    reason: options.reason,
-    rejectMessage: options.rejectMessage
-  });
-}
-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 };
-  },
-  requestApproval(options) {
-    return requestToolApproval(options);
+// src/internal/async-queue.ts
+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 });
+      }
+    }
   }
-};
-
-// src/agent/agent.ts
-import { z } from "zod";
+  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 });
+          });
+        }
+      };
+    }
+  };
+}
 
-// src/request/memory.ts
+// src/internal/prompt-runtime/memory.ts
 var PromptRequestMemory = class {
   constructor(agent, memoryContext, initialHistory) {
     this.agent = agent;
@@ -197,267 +219,7 @@ var PromptRequestMemory = class {
   }
 };
 
-// src/internal/async-queue.ts
-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 });
-          });
-        }
-      };
-    }
-  };
-}
-
-// 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);
-      }
-    }
-  }
-  async event(args) {
-    for (const runObserver of this.runObservers) {
-      if (runObserver.event === void 0) {
-        continue;
-      }
-      try {
-        await runObserver.event(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);
-      }
-    }
-  }
-  async update(args) {
-    for (const observer of this.generationObservers) {
-      if (observer.update === void 0) {
-        continue;
-      }
-      try {
-        await observer.update(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 streamEvent(args) {
-    for (const observer of this.toolObservers) {
-      if (observer.streamEvent === void 0) {
-        continue;
-      }
-      try {
-        await observer.streamEvent(args);
-      } catch (error) {
-        this.handleError(error);
-      }
-    }
-  }
-  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/request/retrieval.ts
+// src/internal/prompt-runtime/retrieval.ts
 async function fetchDynamicContext(agent, ragText) {
   if (ragText === void 0 || ragText.length === 0 || agent.dynamicContexts.length === 0) {
     return [];
@@ -519,28 +281,7 @@ function formatMetadata(metadata) {
   return Object.fromEntries(Object.entries(metadata).map(([key, value]) => [key, String(value)]));
 }
 
-// src/request/utils.ts
-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;
-  }
-}
-
-// src/request/stream-accumulator.ts
+// src/internal/prompt-runtime/stream-accumulator.ts
 var CompletionStreamAccumulator = class _CompletionStreamAccumulator {
   static defaultReasoningKey = "reasoning";
   text = "";
@@ -765,10 +506,38 @@ function isEmptyToolArguments(value) {
   if (typeof value === "object") {
     return Object.values(value).every((item) => item === void 0);
   }
-  return false;
+  return false;
+}
+function parseJsonValue(text) {
+  if (text.trim().length === 0) {
+    return {};
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+
+// src/internal/prompt-runtime/stream-events.ts
+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";
 }
 
-// src/request/tool-execution.ts
+// src/internal/prompt-runtime/tool-execution.ts
 var MCP_TOOL_METADATA_KEY = /* @__PURE__ */ Symbol.for("anvia.mcp.tool.metadata");
 var ToolCallExecutor = class {
   constructor(agent, activeHook, approvals, runContext, concurrency, requestMiddlewares, cancel) {
@@ -1118,23 +887,208 @@ function agentToolEventPayload(toolCall, internalCallId, event) {
   });
 }
 
-// src/request/types.ts
-function addTurn(turn, event) {
-  if (event.type === "text_delta") {
-    return { type: "text_delta", turn, delta: event.delta };
+// src/internal/rag-text.ts
+function extractRagText(message) {
+  if (message.role === "user") {
+    return message.content.flatMap((item) => item.type === "text" ? [item.text] : []).join("\n");
   }
-  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;
+  if (message.role === "tool") {
+    return message.content.flatMap((item) => item.content.flatMap((part) => part.type === "text" ? [part.text] : [])).join("\n");
   }
-  return { type: "tool_call", turn, toolCall: event.toolCall };
+  return void 0;
 }
-function isGenerationDeltaEvent(type) {
-  return type === "text_delta" || type === "reasoning_delta" || type === "tool_call_delta" || type === "tool_call";
+
+// 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);
+      }
+    }
+  }
+  async event(args) {
+    for (const runObserver of this.runObservers) {
+      if (runObserver.event === void 0) {
+        continue;
+      }
+      try {
+        await runObserver.event(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);
+      }
+    }
+  }
+  async update(args) {
+    for (const observer of this.generationObservers) {
+      if (observer.update === void 0) {
+        continue;
+      }
+      try {
+        await observer.update(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 streamEvent(args) {
+    for (const observer of this.toolObservers) {
+      if (observer.streamEvent === void 0) {
+        continue;
+      }
+      try {
+        await observer.streamEvent(args);
+      } catch (error) {
+        this.handleError(error);
+      }
+    }
+  }
+  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/request/prompt-request.ts
 var PromptRequest = class _PromptRequest {
@@ -1817,196 +1771,11 @@ function responseStreamEvents(turn, response) {
   return events;
 }
 
-// src/agent/ids.ts
-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/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;
-  approvals;
-  dynamicContexts;
-  dynamicTools;
-  middlewares;
-  /**
-   * @deprecated Use `middlewares` instead.
-   */
-  toolMiddlewares;
-  memory;
-  eventStore;
-  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.approvals = options.approvals;
-    this.dynamicContexts = options.dynamicContexts ?? [];
-    this.dynamicTools = options.dynamicTools ?? [];
-    this.middlewares = options.middlewares ?? options.toolMiddlewares ?? [];
-    this.toolMiddlewares = this.middlewares;
-    this.memory = options.memory;
-    this.eventStore = options.eventStore;
-  }
-  prompt(prompt) {
-    return PromptRequest.fromAgent(this, prompt);
-  }
-  session(sessionId, options = {}) {
-    if (this.memory === void 0) {
-      throw new Error(`Agent "${this.id}" has no memory store configured.`);
-    }
-    const normalized = sessionId.trim();
-    if (normalized.length === 0) {
-      throw new TypeError("Session id must be a non-empty string.");
-    }
-    return new AgentSession(this, {
-      sessionId: normalized,
-      ...options.userId !== void 0 && { userId: options.userId },
-      ...options.metadata !== void 0 && { metadata: options.metadata }
-    });
-  }
-  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 }, context) => {
-        const request = this.prompt(prompt);
-        const childRequest = options.maxTurns === void 0 ? request : request.maxTurns(options.maxTurns);
-        if (options.stream === true && context.emitStreamEvent !== void 0 && this.model.capabilities.streaming && isStreamingCompletionModel(this.model)) {
-          let output = "";
-          for await (const event of childRequest.stream()) {
-            await context.emitStreamEvent(
-              compact({
-                agentId: this.id,
-                agentName: this.name,
-                event
-              })
-            );
-            if (event.type === "final") {
-              output = event.output;
-            }
-          }
-          return output;
-        }
-        const response = await childRequest.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, context) {
-    if (this.toolSet.contains(toolName)) {
-      return this.toolSet.call(toolName, args, context);
-    }
-    for (const registration of this.dynamicTools) {
-      const toolSet = dynamicToolSetFromIndex(registration.index);
-      if (toolSet?.contains(toolName)) {
-        return toolSet.call(toolName, args, context);
-      }
-    }
-    return this.toolSet.call(toolName, args, context);
-  }
-  shouldApplyToolMiddleware(toolName) {
-    return !isSkillTool(this.getTool(toolName));
-  }
-};
-var AgentSession = class {
-  constructor(agent, context) {
-    this.agent = agent;
-    this.context = context;
-  }
-  agent;
-  context;
-  prompt(prompt) {
-    if (Array.isArray(prompt)) {
-      throw new TypeError("AgentSession.prompt does not accept Message[] transcripts.");
-    }
-    return PromptRequest.fromAgent(this.agent, prompt, { memoryContext: this.context });
-  }
-  async messages() {
-    const memory = this.agent.memory;
-    if (memory === void 0) {
-      throw new Error(`Agent "${this.agent.id}" has no memory store configured.`);
-    }
-    return memory.store.load(this.context);
-  }
-  async clear() {
-    const memory = this.agent.memory;
-    if (memory === void 0) {
-      throw new Error(`Agent "${this.agent.id}" has no memory store configured.`);
-    }
-    await memory.store.clear(this.context);
-  }
-};
-function dynamicToolSetFromIndex(index) {
-  const maybeIndex = index;
-  return maybeIndex.toolSet instanceof ToolSet ? maybeIndex.toolSet : void 0;
-}
-
 export {
   MaxTurnsError,
   PromptCancelledError,
   ToolApprovalRequiredError,
-  createHook,
-  cancelPrompt,
-  skipTool,
-  requestToolApproval,
-  runControl,
-  toolCallControl,
   extractRagText,
-  normalizeAgentId,
-  DEFAULT_MAX_TURNS,
-  Agent,
-  AgentSession
+  PromptRequest
 };
-//# sourceMappingURL=chunk-IFQVPV32.js.map
+//# sourceMappingURL=chunk-SISUMRUX.js.map