@cydm/pie 1.0.14 → 1.0.15

package/dist/chunks/{chunk-D7NAXU7F.js → chunk-5DA2D3K2.js}

@@ -242,6 +242,83 @@ var require_dist = __commonJS({
   }
 });
 
+// ../../packages/ai/src/utils/event-stream.ts
+var EventStream = class {
+  constructor(isComplete, extractResult) {
+    this.isComplete = isComplete;
+    this.extractResult = extractResult;
+    this.finalResultPromise = new Promise((resolve) => {
+      this.resolveFinalResult = resolve;
+    });
+  }
+  isComplete;
+  extractResult;
+  queue = [];
+  waiting = [];
+  done = false;
+  resultResolved = false;
+  finalResultPromise;
+  resolveFinalResult;
+  push(event) {
+    if (this.done) return;
+    if (this.isComplete(event)) {
+      this.done = true;
+      if (!this.resultResolved) {
+        this.resultResolved = true;
+        this.resolveFinalResult(this.extractResult(event));
+      }
+    }
+    const waiter = this.waiting.shift();
+    if (waiter) {
+      waiter({ value: event, done: false });
+    } else {
+      this.queue.push(event);
+    }
+  }
+  end(result) {
+    this.done = true;
+    if (result !== void 0 && !this.resultResolved) {
+      this.resultResolved = true;
+      this.resolveFinalResult(result);
+    }
+    while (this.waiting.length > 0) {
+      const waiter = this.waiting.shift();
+      waiter({ value: void 0, done: true });
+    }
+  }
+  async *[Symbol.asyncIterator]() {
+    while (true) {
+      if (this.queue.length > 0) {
+        yield this.queue.shift();
+      } else if (this.done) {
+        return;
+      } else {
+        const result = await new Promise((resolve) => this.waiting.push(resolve));
+        if (result.done) return;
+        yield result.value;
+      }
+    }
+  }
+  result() {
+    return this.finalResultPromise;
+  }
+};
+var AssistantMessageEventStream = class extends EventStream {
+  constructor() {
+    super(
+      (event) => event.type === "done" || event.type === "error",
+      (event) => {
+        if (event.type === "done") {
+          return event.message;
+        } else if (event.type === "error") {
+          return event.error;
+        }
+        throw new Error("Unexpected event type for final result");
+      }
+    );
+  }
+};
+
 // ../../node_modules/@sinclair/typebox/build/esm/type/guard/value.mjs
 var value_exports = {};
 __export(value_exports, {
@@ -3030,83 +3107,6 @@ function calculateCost(model, usage) {
   };
 }
 
-// ../../packages/ai/src/utils/event-stream.ts
-var EventStream = class {
-  constructor(isComplete, extractResult) {
-    this.isComplete = isComplete;
-    this.extractResult = extractResult;
-    this.finalResultPromise = new Promise((resolve) => {
-      this.resolveFinalResult = resolve;
-    });
-  }
-  isComplete;
-  extractResult;
-  queue = [];
-  waiting = [];
-  done = false;
-  resultResolved = false;
-  finalResultPromise;
-  resolveFinalResult;
-  push(event) {
-    if (this.done) return;
-    if (this.isComplete(event)) {
-      this.done = true;
-      if (!this.resultResolved) {
-        this.resultResolved = true;
-        this.resolveFinalResult(this.extractResult(event));
-      }
-    }
-    const waiter = this.waiting.shift();
-    if (waiter) {
-      waiter({ value: event, done: false });
-    } else {
-      this.queue.push(event);
-    }
-  }
-  end(result) {
-    this.done = true;
-    if (result !== void 0 && !this.resultResolved) {
-      this.resultResolved = true;
-      this.resolveFinalResult(result);
-    }
-    while (this.waiting.length > 0) {
-      const waiter = this.waiting.shift();
-      waiter({ value: void 0, done: true });
-    }
-  }
-  async *[Symbol.asyncIterator]() {
-    while (true) {
-      if (this.queue.length > 0) {
-        yield this.queue.shift();
-      } else if (this.done) {
-        return;
-      } else {
-        const result = await new Promise((resolve) => this.waiting.push(resolve));
-        if (result.done) return;
-        yield result.value;
-      }
-    }
-  }
-  result() {
-    return this.finalResultPromise;
-  }
-};
-var AssistantMessageEventStream = class extends EventStream {
-  constructor() {
-    super(
-      (event) => event.type === "done" || event.type === "error",
-      (event) => {
-        if (event.type === "done") {
-          return event.message;
-        } else if (event.type === "error") {
-          return event.error;
-        }
-        throw new Error("Unexpected event type for final result");
-      }
-    );
-  }
-};
-
 // ../../packages/platform/src/detector.ts
 function isPuerTS() {
   try {
@@ -9120,1023 +9120,6 @@ registerApiProvider({
   streamSimple: streamSimpleAnthropic
 });
 
-// ../../packages/agent-core/src/agent-loop.ts
-function createLoopErrorMessage(error, config, signal) {
-  const message = error instanceof Error ? error.message : String(error);
-  return {
-    role: "assistant",
-    content: [{ type: "text", text: "" }],
-    api: config.model.api,
-    provider: config.model.provider,
-    model: config.model.id,
-    usage: {
-      input: 0,
-      output: 0,
-      cacheRead: 0,
-      cacheWrite: 0,
-      totalTokens: 0,
-      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
-    },
-    stopReason: signal?.aborted ? "aborted" : "error",
-    errorMessage: message,
-    timestamp: Date.now()
-  };
-}
-async function notifyOnError(config, error, phase) {
-  try {
-    await config.hooks?.onError?.(error instanceof Error ? error : new Error(String(error)), { phase });
-  } catch (hookError) {
-    console.warn(`[AgentLoop] onError hook failed during ${phase}:`, hookError);
-  }
-}
-function endStreamWithError(stream, newMessages, config, signal, error) {
-  const errorMessage = createLoopErrorMessage(error, config, signal);
-  newMessages.push(errorMessage);
-  stream.push({ type: "message_start", message: errorMessage });
-  stream.push({ type: "message_end", message: errorMessage });
-  stream.push({ type: "turn_end", message: errorMessage, toolResults: [] });
-  stream.push({ type: "agent_end", messages: newMessages });
-  stream.end(newMessages);
-}
-function agentLoop(prompts, context, config, signal, streamFn) {
-  const stream = createAgentStream();
-  (async () => {
-    const newMessages = [...prompts];
-    try {
-      try {
-        await config.hooks?.beforeAgentStart?.();
-      } catch (e) {
-        console.warn("[AgentLoop] beforeAgentStart hook failed:", e);
-      }
-      const currentContext = {
-        ...context,
-        messages: [...context.messages, ...prompts]
-      };
-      stream.push({ type: "agent_start" });
-      stream.push({ type: "turn_start" });
-      for (const prompt of prompts) {
-        stream.push({ type: "message_start", message: prompt });
-        stream.push({ type: "message_end", message: prompt });
-      }
-      try {
-        await runLoop(currentContext, newMessages, config, signal, stream, streamFn);
-      } catch (error) {
-        await notifyOnError(config, error, "runLoop");
-        endStreamWithError(stream, newMessages, config, signal, error);
-        return;
-      }
-      try {
-        await config.hooks?.afterAgentEnd?.(newMessages);
-      } catch (e) {
-        console.warn("[AgentLoop] afterAgentEnd hook failed:", e);
-      }
-    } catch (error) {
-      await notifyOnError(config, error, "agentLoop");
-      endStreamWithError(stream, newMessages, config, signal, error);
-    }
-  })();
-  return stream;
-}
-function agentLoopContinue(context, config, signal, streamFn) {
-  if (context.messages.length === 0) {
-    throw new Error("Cannot continue: no messages in context");
-  }
-  if (context.messages[context.messages.length - 1].role === "assistant") {
-    throw new Error("Cannot continue from message role: assistant");
-  }
-  const stream = createAgentStream();
-  (async () => {
-    const newMessages = [];
-    try {
-      try {
-        await config.hooks?.beforeAgentStart?.();
-      } catch (e) {
-        console.warn("[AgentLoop] beforeAgentStart hook failed:", e);
-      }
-      const currentContext = { ...context };
-      stream.push({ type: "agent_start" });
-      stream.push({ type: "turn_start" });
-      try {
-        await runLoop(currentContext, newMessages, config, signal, stream, streamFn);
-      } catch (error) {
-        await notifyOnError(config, error, "runLoop");
-        endStreamWithError(stream, newMessages, config, signal, error);
-        return;
-      }
-      try {
-        await config.hooks?.afterAgentEnd?.(newMessages);
-      } catch (e) {
-        console.warn("[AgentLoop] afterAgentEnd hook failed:", e);
-      }
-    } catch (error) {
-      await notifyOnError(config, error, "agentLoopContinue");
-      endStreamWithError(stream, newMessages, config, signal, error);
-    }
-  })();
-  return stream;
-}
-function createAgentStream() {
-  return new EventStream(
-    (event) => event.type === "agent_end",
-    (event) => event.type === "agent_end" ? event.messages : []
-  );
-}
-async function runLoop(currentContext, newMessages, config, signal, stream, streamFn) {
-  let firstTurn = true;
-  let pendingMessages = await config.getSteeringMessages?.() || [];
-  while (true) {
-    let hasMoreToolCalls = true;
-    let steeringAfterTools = null;
-    while (hasMoreToolCalls || pendingMessages.length > 0) {
-      if (!firstTurn) {
-        stream.push({ type: "turn_start" });
-      } else {
-        firstTurn = false;
-      }
-      if (pendingMessages.length > 0) {
-        for (const message2 of pendingMessages) {
-          stream.push({ type: "message_start", message: message2 });
-          stream.push({ type: "message_end", message: message2 });
-          currentContext.messages.push(message2);
-          newMessages.push(message2);
-        }
-        pendingMessages = [];
-      }
-      let message;
-      try {
-        message = await streamAssistantResponse(currentContext, config, signal, stream, streamFn);
-      } catch (error) {
-        await notifyOnError(config, error, "streamAssistantResponse");
-        throw error;
-      }
-      newMessages.push(message);
-      if (message.stopReason === "error" || message.stopReason === "aborted") {
-        stream.push({ type: "turn_end", message, toolResults: [] });
-        stream.push({ type: "agent_end", messages: newMessages });
-        stream.end(newMessages);
-        return;
-      }
-      const toolCalls = message.content.filter((c) => c.type === "toolCall");
-      hasMoreToolCalls = toolCalls.length > 0;
-      const toolResults = [];
-      if (hasMoreToolCalls) {
-        const toolExecution = await executeToolCalls(
-          currentContext.tools,
-          message,
-          signal,
-          stream,
-          config.getSteeringMessages,
-          config.hooks
-        );
-        toolResults.push(...toolExecution.toolResults);
-        steeringAfterTools = toolExecution.steeringMessages ?? null;
-        for (const result of toolResults) {
-          currentContext.messages.push(result);
-          newMessages.push(result);
-        }
-      }
-      stream.push({ type: "turn_end", message, toolResults });
-      if (steeringAfterTools && steeringAfterTools.length > 0) {
-        pendingMessages = steeringAfterTools;
-        steeringAfterTools = null;
-      } else {
-        pendingMessages = await config.getSteeringMessages?.() || [];
-      }
-    }
-    const followUpMessages = await config.getFollowUpMessages?.() || [];
-    if (followUpMessages.length > 0) {
-      pendingMessages = followUpMessages;
-      continue;
-    }
-    break;
-  }
-  stream.push({ type: "agent_end", messages: newMessages });
-  stream.end(newMessages);
-}
-async function streamAssistantResponse(context, config, signal, stream, streamFn) {
-  let messages = context.messages;
-  if (config.transformContext) {
-    messages = await config.transformContext(messages, signal);
-  }
-  const llmMessages = await config.convertToLlm(messages);
-  const llmContext = {
-    systemPrompt: context.systemPrompt,
-    messages: llmMessages,
-    tools: context.tools
-  };
-  const streamFunction = streamFn || streamSimple;
-  const resolvedApiKey = (config.getApiKey ? await config.getApiKey(config.model.provider) : void 0) || config.apiKey;
-  const response = await streamFunction(config.model, llmContext, {
-    ...config,
-    apiKey: resolvedApiKey,
-    signal
-  });
-  let partialMessage = null;
-  let addedPartial = false;
-  for await (const event of response) {
-    switch (event.type) {
-      case "start":
-        partialMessage = event.partial;
-        context.messages.push(partialMessage);
-        addedPartial = true;
-        stream.push({ type: "message_start", message: { ...partialMessage } });
-        break;
-      case "text_start":
-      case "text_delta":
-      case "text_end":
-      case "thinking_start":
-      case "thinking_delta":
-      case "thinking_end":
-      case "toolcall_start":
-      case "toolcall_delta":
-      case "toolcall_end":
-        if (partialMessage) {
-          partialMessage = event.partial;
-          context.messages[context.messages.length - 1] = partialMessage;
-          stream.push({
-            type: "message_update",
-            assistantMessageEvent: event,
-            message: { ...partialMessage }
-          });
-        }
-        break;
-      case "done":
-      case "error": {
-        const finalMessage = await response.result();
-        if (addedPartial) {
-          context.messages[context.messages.length - 1] = finalMessage;
-        } else {
-          context.messages.push(finalMessage);
-        }
-        if (!addedPartial) {
-          stream.push({ type: "message_start", message: { ...finalMessage } });
-        }
-        stream.push({ type: "message_end", message: finalMessage });
-        return finalMessage;
-      }
-    }
-  }
-  return await response.result();
-}
-async function executeToolCalls(tools, assistantMessage, signal, stream, getSteeringMessages, hooks) {
-  const toolCalls = assistantMessage.content.filter((c) => c.type === "toolCall");
-  const results = [];
-  let steeringMessages;
-  for (let index = 0; index < toolCalls.length; index++) {
-    const toolCall = toolCalls[index];
-    const tool = tools?.find((t) => t.name === toolCall.name);
-    let blocked = false;
-    let blockReason;
-    try {
-      const hookResult = await hooks?.beforeToolCall?.(toolCall.name, toolCall.arguments);
-      if (hookResult && hookResult.block) {
-        blocked = true;
-        blockReason = hookResult.reason || "Blocked by hook";
-      }
-    } catch (e) {
-      console.warn(`[AgentLoop] beforeToolCall hook failed for ${toolCall.name}:`, e);
-    }
-    let result;
-    let isError = false;
-    let executionArgs = toolCall.arguments;
-    let started = false;
-    const pushToolStart = () => {
-      if (started) return;
-      started = true;
-      stream.push({
-        type: "tool_execution_start",
-        toolCallId: toolCall.id,
-        toolName: toolCall.name,
-        args: executionArgs
-      });
-    };
-    if (blocked) {
-      pushToolStart();
-      result = {
-        content: [{ type: "text", text: `Tool execution blocked: ${blockReason}` }],
-        details: { blocked: true, reason: blockReason }
-      };
-      isError = true;
-    } else {
-      try {
-        if (!tool) {
-          throw new Error(`Tool ${toolCall.name} not found`);
-        }
-        const validatedArgs = validateToolArguments(tool, toolCall);
-        executionArgs = validatedArgs;
-        pushToolStart();
-        result = await tool.execute(toolCall.id, validatedArgs, signal, (partialResult) => {
-          stream.push({
-            type: "tool_execution_update",
-            toolCallId: toolCall.id,
-            toolName: toolCall.name,
-            args: executionArgs,
-            partialResult
-          });
-        });
-        isError = isError || !!result.isError;
-      } catch (e) {
-        pushToolStart();
-        result = {
-          content: [{ type: "text", text: e instanceof Error ? e.message : String(e) }],
-          details: {}
-        };
-        isError = true;
-        try {
-          await hooks?.onError?.(e instanceof Error ? e : new Error(String(e)), {
-            toolName: toolCall.name,
-            phase: "toolExecution"
-          });
-        } catch (hookError) {
-          console.warn(`[AgentLoop] onError hook failed during toolExecution for ${toolCall.name}:`, hookError);
-        }
-      }
-    }
-    try {
-      await hooks?.afterToolCall?.(toolCall.name, toolCall.arguments, result, isError);
-    } catch (e) {
-      console.warn(`[AgentLoop] afterToolCall hook failed for ${toolCall.name}:`, e);
-    }
-    stream.push({
-      type: "tool_execution_end",
-      toolCallId: toolCall.id,
-      toolName: toolCall.name,
-      args: executionArgs,
-      result,
-      isError
-    });
-    const toolResultMessage = {
-      role: "toolResult",
-      toolCallId: toolCall.id,
-      toolName: toolCall.name,
-      content: result.content,
-      details: result.details,
-      isError,
-      timestamp: Date.now()
-    };
-    results.push(toolResultMessage);
-    stream.push({ type: "message_start", message: toolResultMessage });
-    stream.push({ type: "message_end", message: toolResultMessage });
-    if (getSteeringMessages) {
-      const steering = await getSteeringMessages();
-      if (steering.length > 0) {
-        steeringMessages = steering;
-        const remainingCalls = toolCalls.slice(index + 1);
-        for (const skipped of remainingCalls) {
-          results.push(skipToolCall(skipped, stream));
-        }
-        break;
-      }
-    }
-  }
-  return { toolResults: results, steeringMessages };
-}
-function skipToolCall(toolCall, stream) {
-  const result = {
-    content: [{ type: "text", text: "Skipped due to queued user message." }],
-    details: {}
-  };
-  stream.push({
-    type: "tool_execution_start",
-    toolCallId: toolCall.id,
-    toolName: toolCall.name,
-    args: toolCall.arguments
-  });
-  stream.push({
-    type: "tool_execution_end",
-    toolCallId: toolCall.id,
-    toolName: toolCall.name,
-    args: toolCall.arguments,
-    result,
-    isError: true
-  });
-  const toolResultMessage = {
-    role: "toolResult",
-    toolCallId: toolCall.id,
-    toolName: toolCall.name,
-    content: result.content,
-    details: {},
-    isError: true,
-    timestamp: Date.now()
-  };
-  stream.push({ type: "message_start", message: toolResultMessage });
-  stream.push({ type: "message_end", message: toolResultMessage });
-  return toolResultMessage;
-}
-
-// ../../packages/agent-core/src/agent.ts
-function defaultConvertToLlm(messages) {
-  return messages.filter((m) => m.role === "user" || m.role === "assistant" || m.role === "toolResult");
-}
-function isAgentMessage(value) {
-  return !!value && typeof value === "object" && "role" in value;
-}
-function isUserContentBlock(value) {
-  if (!value || typeof value !== "object" || !("type" in value)) {
-    return false;
-  }
-  const type = value.type;
-  return type === "text" || type === "image" || type === "audio" || type === "video" || type === "fileRef";
-}
-var Agent = class {
-  _state;
-  listeners = /* @__PURE__ */ new Set();
-  semanticListeners = /* @__PURE__ */ new Set();
-  abortController;
-  convertToLlm;
-  transformContext;
-  steeringQueue = [];
-  followUpQueue = [];
-  steeringMode;
-  followUpMode;
-  streamFn;
-  _sessionId;
-  _apiKey;
-  getApiKey;
-  runningPrompt;
-  resolveRunningPrompt;
-  _thinkingBudgets;
-  _maxRetryDelayMs;
-  hooks;
-  statusSnapshot = {
-    phase: "idle",
-    turnState: "completed",
-    hasPendingToolContinuation: false
-  };
-  constructor(opts = {}) {
-    this._state = {
-      systemPrompt: "",
-      model: null,
-      // Must be set before use
-      thinkingLevel: "off",
-      tools: [],
-      messages: [],
-      isStreaming: false,
-      streamMessage: null,
-      pendingToolCalls: /* @__PURE__ */ new Set(),
-      error: void 0,
-      ...opts.initialState
-    };
-    this.convertToLlm = opts.convertToLlm || defaultConvertToLlm;
-    this.transformContext = opts.transformContext;
-    this.steeringMode = opts.steeringMode || "one-at-a-time";
-    this.followUpMode = opts.followUpMode || "one-at-a-time";
-    this.streamFn = opts.streamFn || streamSimple;
-    this._sessionId = opts.sessionId;
-    this._apiKey = opts.apiKey;
-    this.getApiKey = opts.getApiKey;
-    this._thinkingBudgets = opts.thinkingBudgets;
-    this._maxRetryDelayMs = opts.maxRetryDelayMs;
-    this.hooks = opts.initialState?.hooks;
-  }
-  get sessionId() {
-    return this._sessionId;
-  }
-  set sessionId(value) {
-    this._sessionId = value;
-  }
-  get apiKey() {
-    return this._apiKey;
-  }
-  set apiKey(value) {
-    this._apiKey = value;
-  }
-  get thinkingBudgets() {
-    return this._thinkingBudgets;
-  }
-  set thinkingBudgets(value) {
-    this._thinkingBudgets = value;
-  }
-  get maxRetryDelayMs() {
-    return this._maxRetryDelayMs;
-  }
-  set maxRetryDelayMs(value) {
-    this._maxRetryDelayMs = value;
-  }
-  get state() {
-    return this._state;
-  }
-  subscribe(fn) {
-    this.listeners.add(fn);
-    return () => this.listeners.delete(fn);
-  }
-  subscribeSemantic(fn) {
-    this.semanticListeners.add(fn);
-    return () => this.semanticListeners.delete(fn);
-  }
-  getStatusSnapshot() {
-    return { ...this.statusSnapshot };
-  }
-  setSystemPrompt(v) {
-    this._state.systemPrompt = v;
-  }
-  setModel(m) {
-    this._state.model = m;
-  }
-  setThinkingLevel(l) {
-    this._state.thinkingLevel = l;
-  }
-  setTools(t) {
-    this._state.tools = t;
-  }
-  setHooks(hooks) {
-    this.hooks = hooks;
-  }
-  replaceMessages(ms) {
-    this._state.messages = ms.slice();
-  }
-  appendMessage(m) {
-    this._state.messages = [...this._state.messages, m];
-  }
-  clearMessages() {
-    this._state.messages = [];
-  }
-  steer(m) {
-    this.steeringQueue.push(m);
-  }
-  followUp(m) {
-    this.followUpQueue.push(m);
-  }
-  clearSteeringQueue() {
-    this.steeringQueue = [];
-  }
-  clearFollowUpQueue() {
-    this.followUpQueue = [];
-  }
-  clearAllQueues() {
-    this.steeringQueue = [];
-    this.followUpQueue = [];
-  }
-  hasQueuedMessages() {
-    return this.steeringQueue.length > 0 || this.followUpQueue.length > 0;
-  }
-  setSteeringMode(mode) {
-    this.steeringMode = mode;
-  }
-  getSteeringMode() {
-    return this.steeringMode;
-  }
-  setFollowUpMode(mode) {
-    this.followUpMode = mode;
-  }
-  getFollowUpMode() {
-    return this.followUpMode;
-  }
-  dequeueSteeringMessages() {
-    if (this.steeringMode === "one-at-a-time") {
-      if (this.steeringQueue.length > 0) {
-        const first = this.steeringQueue[0];
-        this.steeringQueue = this.steeringQueue.slice(1);
-        return [first];
-      }
-      return [];
-    }
-    const steering = this.steeringQueue.slice();
-    this.steeringQueue = [];
-    return steering;
-  }
-  dequeueFollowUpMessages() {
-    if (this.followUpMode === "one-at-a-time") {
-      if (this.followUpQueue.length > 0) {
-        const first = this.followUpQueue[0];
-        this.followUpQueue = this.followUpQueue.slice(1);
-        return [first];
-      }
-      return [];
-    }
-    const followUp = this.followUpQueue.slice();
-    this.followUpQueue = [];
-    return followUp;
-  }
-  abort() {
-    this.abortController?.abort();
-  }
-  waitForIdle() {
-    return this.runningPrompt ?? Promise.resolve();
-  }
-  reset() {
-    this._state.messages = [];
-    this._state.isStreaming = false;
-    this._state.streamMessage = null;
-    this._state.pendingToolCalls = /* @__PURE__ */ new Set();
-    this._state.error = void 0;
-    this.steeringQueue = [];
-    this.followUpQueue = [];
-    this.runningPrompt = void 0;
-    this.resolveRunningPrompt = void 0;
-    this.updateStatusSnapshot({
-      phase: "idle",
-      turnState: "completed",
-      activeToolName: void 0,
-      lastStopReason: void 0,
-      hasPendingToolContinuation: false
-    });
-  }
-  /**
-   * Reset only the processing state without clearing messages.
-   * Useful when resuming a session that was saved mid-processing.
-   */
-  resetProcessingState() {
-    this._state.isStreaming = false;
-    this._state.streamMessage = null;
-    this._state.pendingToolCalls = /* @__PURE__ */ new Set();
-    this._state.error = void 0;
-    this.steeringQueue = [];
-    this.followUpQueue = [];
-    this.runningPrompt = void 0;
-    this.resolveRunningPrompt = void 0;
-    this.abortController = void 0;
-    this.updateStatusSnapshot({
-      phase: "idle",
-      turnState: "completed",
-      activeToolName: void 0,
-      lastStopReason: void 0,
-      hasPendingToolContinuation: false
-    });
-  }
-  async prompt(input, images) {
-    if (this.runningPrompt) {
-      throw new Error("Agent is already processing a prompt.");
-    }
-    if (this._state.isStreaming) {
-      throw new Error("Agent is already processing a prompt.");
-    }
-    const promise = new Promise((resolve) => {
-      this.resolveRunningPrompt = resolve;
-    });
-    this.runningPrompt = promise;
-    try {
-      const model = this._state.model;
-      if (!model) throw new Error("No model configured");
-      let msgs;
-      if (Array.isArray(input)) {
-        if (input.length > 0 && input.every((item) => isUserContentBlock(item))) {
-          msgs = [{ role: "user", content: input, timestamp: Date.now() }];
-        } else if (input.every((item) => isAgentMessage(item))) {
-          msgs = input;
-        } else {
-          throw new Error("Invalid prompt array: expected user content blocks or agent messages.");
-        }
-      } else if (typeof input === "string") {
-        const content = [{ type: "text", text: input }];
-        if (images && images.length > 0) {
-          content.push(...images);
-        }
-        msgs = [{ role: "user", content, timestamp: Date.now() }];
-      } else {
-        msgs = [input];
-      }
-      await this._runLoop(msgs);
-    } finally {
-      if (this.runningPrompt === promise) {
-        this.resolveRunningPrompt?.();
-        this.runningPrompt = void 0;
-        this.resolveRunningPrompt = void 0;
-      }
-    }
-  }
-  async continue() {
-    if (this.runningPrompt) {
-      throw new Error("Agent is already processing.");
-    }
-    if (this._state.isStreaming) {
-      throw new Error("Agent is already processing.");
-    }
-    const promise = new Promise((resolve) => {
-      this.resolveRunningPrompt = resolve;
-    });
-    this.runningPrompt = promise;
-    try {
-      const messages = this._state.messages;
-      if (messages.length === 0) {
-        throw new Error("No messages to continue from");
-      }
-      if (messages[messages.length - 1].role === "assistant") {
-        const queuedSteering = this.dequeueSteeringMessages();
-        if (queuedSteering.length > 0) {
-          await this._runLoop(queuedSteering, {
-            skipInitialSteeringPoll: true,
-            suppressSteeringPolls: true,
-            suppressFollowUpPolls: true
-          });
-          return;
-        }
-        const queuedFollowUp = this.dequeueFollowUpMessages();
-        if (queuedFollowUp.length > 0) {
-          await this._runLoop(queuedFollowUp, {
-            suppressSteeringPolls: true,
-            suppressFollowUpPolls: true
-          });
-          return;
-        }
-        throw new Error("Cannot continue from message role: assistant");
-      }
-      await this._runLoop(void 0);
-    } finally {
-      if (this.runningPrompt === promise) {
-        this.resolveRunningPrompt?.();
-        this.runningPrompt = void 0;
-        this.resolveRunningPrompt = void 0;
-      }
-    }
-  }
-  async _runLoop(messages, options) {
-    const model = this._state.model;
-    if (!model) throw new Error("No model configured");
-    this.abortController = new AbortController();
-    this._state.isStreaming = true;
-    this._state.streamMessage = null;
-    this._state.error = void 0;
-    const reasoning = this._state.thinkingLevel === "off" ? void 0 : this._state.thinkingLevel;
-    const context = {
-      systemPrompt: this._state.systemPrompt,
-      messages: this._state.messages.slice(),
-      tools: this._state.tools
-    };
-    let skipInitialSteeringPoll = options?.skipInitialSteeringPoll === true;
-    const config = {
-      model,
-      reasoning,
-      apiKey: this._apiKey,
-      sessionId: this._sessionId,
-      thinkingBudgets: this._thinkingBudgets,
-      maxRetryDelayMs: this._maxRetryDelayMs,
-      convertToLlm: this.convertToLlm,
-      transformContext: this.transformContext,
-      getApiKey: this.getApiKey,
-      hooks: this.hooks,
-      getSteeringMessages: async () => {
-        if (options?.suppressSteeringPolls) {
-          return [];
-        }
-        if (skipInitialSteeringPoll) {
-          skipInitialSteeringPoll = false;
-          return [];
-        }
-        return this.dequeueSteeringMessages();
-      },
-      getFollowUpMessages: async () => {
-        if (options?.suppressFollowUpPolls) {
-          return [];
-        }
-        return this.dequeueFollowUpMessages();
-      }
-    };
-    let partial = null;
-    try {
-      const stream = messages ? agentLoop(messages, context, config, this.abortController.signal, this.streamFn) : agentLoopContinue(context, config, this.abortController.signal, this.streamFn);
-      for await (const event of stream) {
-        switch (event.type) {
-          case "message_start":
-            partial = event.message;
-            this._state.streamMessage = event.message;
-            break;
-          case "message_update":
-            partial = event.message;
-            this._state.streamMessage = event.message;
-            break;
-          case "message_end":
-            partial = null;
-            this._state.streamMessage = null;
-            this.appendMessage(event.message);
-            break;
-          case "tool_execution_start": {
-            const s = new Set(this._state.pendingToolCalls);
-            s.add(event.toolCallId);
-            this._state.pendingToolCalls = s;
-            break;
-          }
-          case "tool_execution_end": {
-            const s = new Set(this._state.pendingToolCalls);
-            s.delete(event.toolCallId);
-            this._state.pendingToolCalls = s;
-            break;
-          }
-          case "turn_end":
-            if (event.message.role === "assistant" && event.message.errorMessage) {
-              this._state.error = event.message.errorMessage;
-            }
-            break;
-          case "agent_end":
-            this._state.isStreaming = false;
-            this._state.streamMessage = null;
-            break;
-        }
-        this.emit(event);
-      }
-      if (partial && partial.role === "assistant" && partial.content?.length > 0) {
-        const onlyEmpty = !partial.content.some(
-          (c) => c.type === "thinking" && c.thinking?.trim().length > 0 || c.type === "text" && c.text?.trim().length > 0 || c.type === "toolCall" && c.name?.trim().length > 0
-        );
-        if (!onlyEmpty) {
-          this.appendMessage(partial);
-        }
-      }
-    } catch (err) {
-      const errorMsg = {
-        role: "assistant",
-        content: [{ type: "text", text: "" }],
-        api: model.api,
-        provider: model.provider,
-        model: model.id,
-        usage: {
-          input: 0,
-          output: 0,
-          cacheRead: 0,
-          cacheWrite: 0,
-          totalTokens: 0,
-          cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
-        },
-        stopReason: this.abortController?.signal.aborted ? "aborted" : "error",
-        errorMessage: err?.message || String(err),
-        timestamp: Date.now()
-      };
-      this.appendMessage(errorMsg);
-      this._state.error = err?.message || String(err);
-      this.emit({ type: "agent_end", messages: [errorMsg] });
-    } finally {
-      this._state.isStreaming = false;
-      this._state.streamMessage = null;
-      this._state.pendingToolCalls = /* @__PURE__ */ new Set();
-      this.abortController = void 0;
-    }
-  }
-  reportObserverError(kind, eventType, error) {
-    console.warn(`[Agent] ${kind} failed while handling ${eventType}:`, error);
-  }
-  emit(e) {
-    for (const listener of this.listeners) {
-      try {
-        listener(e);
-      } catch (error) {
-        this.reportObserverError("agent event listener", e.type, error);
-      }
-    }
-    try {
-      this.emitDerivedSemanticEvents(e);
-    } catch (error) {
-      this.reportObserverError("derived semantic event", e.type, error);
-    }
-  }
-  emitSemantic(e) {
-    for (const listener of this.semanticListeners) {
-      try {
-        listener(e);
-      } catch (error) {
-        this.reportObserverError("semantic event listener", e.type, error);
-      }
-    }
-  }
-  updateStatusSnapshot(next) {
-    const snapshot = {
-      ...this.statusSnapshot,
-      ...next
-    };
-    if (snapshot.phase === this.statusSnapshot.phase && snapshot.turnState === this.statusSnapshot.turnState && snapshot.activeToolName === this.statusSnapshot.activeToolName && snapshot.lastStopReason === this.statusSnapshot.lastStopReason && snapshot.hasPendingToolContinuation === this.statusSnapshot.hasPendingToolContinuation) {
-      return;
-    }
-    this.statusSnapshot = snapshot;
-    this.emitSemantic({ type: "status_snapshot_changed", snapshot: { ...snapshot } });
-  }
-  emitDerivedSemanticEvents(event) {
-    switch (event.type) {
-      case "message_start":
-        if (event.message.role === "assistant") {
-          this.updateStatusSnapshot({
-            phase: "responding",
-            turnState: "continuing",
-            activeToolName: void 0,
-            lastStopReason: void 0,
-            hasPendingToolContinuation: false
-          });
-          this.emitSemantic({ type: "assistant_response_started", message: event.message });
-        }
-        break;
-      case "message_update":
-        if (event.message.role === "assistant" && event.assistantMessageEvent.type === "text_delta") {
-          this.updateStatusSnapshot({ phase: "responding" });
-          this.emitSemantic({
-            type: "assistant_response_delta",
-            message: event.message,
-            delta: event.assistantMessageEvent.delta
-          });
-        }
-        break;
-      case "message_end":
-        if (event.message.role === "assistant") {
-          this.emitSemantic({ type: "assistant_response_finished", message: event.message });
-        }
-        break;
-      case "tool_execution_start":
-        this.updateStatusSnapshot({
-          phase: "running_tool",
-          turnState: "continuing",
-          activeToolName: event.toolName,
-          lastStopReason: void 0,
-          hasPendingToolContinuation: false
-        });
-        this.emitSemantic({
-          type: "tool_started",
-          toolCallId: event.toolCallId,
-          toolName: event.toolName,
-          args: event.args
-        });
-        break;
-      case "tool_execution_update":
-        this.emitSemantic({
-          type: "tool_progressed",
-          toolCallId: event.toolCallId,
-          toolName: event.toolName,
-          args: event.args,
-          partialResult: event.partialResult
-        });
-        break;
-      case "tool_execution_end":
-        this.updateStatusSnapshot({
-          phase: this._state.isStreaming ? "responding" : "completed",
-          activeToolName: void 0
-        });
-        this.emitSemantic({
-          type: "tool_finished",
-          toolCallId: event.toolCallId,
-          toolName: event.toolName,
-          args: event.args,
-          result: event.result,
-          isError: event.isError
-        });
-        break;
-      case "turn_end": {
-        const stopReason = event.message.role === "assistant" ? event.message.stopReason : void 0;
-        const hasToolCalls = event.message.role === "assistant" && Array.isArray(event.message.content) && event.message.content.some((block) => block.type === "toolCall");
-        if (stopReason === "error" || stopReason === "aborted") {
-          this.updateStatusSnapshot({
-            phase: "failed",
-            turnState: "failed",
-            lastStopReason: stopReason,
-            hasPendingToolContinuation: false,
-            activeToolName: void 0
-          });
-          this.emitSemantic({
-            type: "turn_failed",
-            message: event.message,
-            toolResults: event.toolResults
-          });
-        } else if (hasToolCalls || stopReason === "toolUse") {
-          this.updateStatusSnapshot({
-            phase: "responding",
-            turnState: "continuing",
-            lastStopReason: stopReason,
-            hasPendingToolContinuation: true,
-            activeToolName: void 0
-          });
-          this.emitSemantic({
-            type: "turn_continues",
-            message: event.message,
-            toolResults: event.toolResults
-          });
-        } else {
-          this.updateStatusSnapshot({
-            phase: "completed",
-            turnState: "completed",
-            lastStopReason: stopReason,
-            hasPendingToolContinuation: false,
-            activeToolName: void 0
-          });
-          this.emitSemantic({
-            type: "turn_completed",
-            message: event.message,
-            toolResults: event.toolResults
-          });
-        }
-        break;
-      }
-      case "agent_end": {
-        const lastMessage = event.messages[event.messages.length - 1];
-        if (lastMessage?.role === "assistant" && (lastMessage.stopReason === "error" || lastMessage.stopReason === "aborted")) {
-          this.updateStatusSnapshot({
-            phase: "failed",
-            turnState: "failed",
-            lastStopReason: lastMessage.stopReason,
-            hasPendingToolContinuation: false,
-            activeToolName: void 0
-          });
-          this.emitSemantic({
-            type: "turn_failed",
-            message: lastMessage,
-            toolResults: []
-          });
-        }
-        this.updateStatusSnapshot({
-          phase: "idle",
-          activeToolName: void 0,
-          hasPendingToolContinuation: false
-        });
-        break;
-      }
-    }
-  }
-};
-
 export {
   detectPlatform,
   createLogger,
@@ -10160,6 +9143,7 @@ export {
   KeyOfPattern,
   ExtendsUndefinedCheck,
   Type,
+  EventStream,
   getModelCacheCapability,
   streamSimple,
   completeSimple,
@@ -10175,7 +9159,5 @@ export {
   TransformEncodeCheckError,
   TransformEncode,
   HasTransform,
-  agentLoop,
-  agentLoopContinue,
-  Agent
+  validateToolArguments
 };