@cydm/pie 1.0.14 → 1.0.15

package/dist/chunks/chunk-VE2HDCNB.js

@@ -0,0 +1,1029 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  EventStream,
+  streamSimple,
+  validateToolArguments
+} from "./chunk-5DA2D3K2.js";
+
+// ../../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 {
+  agentLoop,
+  agentLoopContinue,
+  Agent
+};