nolo-cli 0.1.19 → 0.1.21

package/README.md

@@ -169,12 +169,20 @@ nolo agent list
 nolo agent switch <agent>
 nolo agent read <agent>
 nolo agent run <agent> "检查最近失败任务"
+nolo agent run frontend-implementer --msg "修一个小的通知弹窗 CSS 问题"
 nolo dialog list --agent <agent>
 nolo dialog read <dialog>
 nolo doc list --agent <agent>
-nolo table query <table> --agent <agent>
+nolo table query --table meta-b2e06f801f-NOLOTASKBOARD --limit 20
+nolo table query --table meta-b2e06f801f-NOLOTASKBOARD --columns '["title","status","owner","priority","codeStatus"]' --no-base-fields --output items
+nolo table update-row --table meta-b2e06f801f-NOLOTASKBOARD --row 01ROWID --changes '{"status":"已完成"}'
+nolo table add-column --table meta-b2e06f801f-NOLOTASKBOARD --schema-write-ok --name "blockedBy" --label "Blocked By"
 ```
 
+`nolo table add-column` mutates table schema metadata, so it requires
+`--schema-write-ok` and should be run serially per table. Row-level table writes
+do not require this flag.
+
 Inside the current TUI, examples of supported slash commands include:
 `/agent`, `/agents`, `/switch`, `/context` (alias `/ctx`), `/dialog`, `/doc`,
 `/help`, `/new`, `/customize`, `/login`, `/profile`, `/version`, `/quit`

package/agent-runtime/agentConfigOptions.ts

@@ -0,0 +1,12 @@
+import type { AgentRuntimeAgentConfig } from "./hostAdapter";
+
+export function pickAgentRuntimeInferenceOptions(agentConfig: AgentRuntimeAgentConfig) {
+  return {
+    ...(agentConfig.temperature !== undefined ? { temperature: agentConfig.temperature } : {}),
+    ...(agentConfig.top_p !== undefined ? { top_p: agentConfig.top_p } : {}),
+    ...(agentConfig.frequency_penalty !== undefined ? { frequency_penalty: agentConfig.frequency_penalty } : {}),
+    ...(agentConfig.presence_penalty !== undefined ? { presence_penalty: agentConfig.presence_penalty } : {}),
+    ...(agentConfig.max_tokens !== undefined ? { max_tokens: agentConfig.max_tokens } : {}),
+    ...(agentConfig.reasoning_effort ? { reasoning_effort: agentConfig.reasoning_effort } : {}),
+  };
+}

package/agent-runtime/agentRecordConfig.ts

@@ -0,0 +1,99 @@
+import type { AgentRuntimeAgentConfig } from "./hostAdapter";
+
+type AgentRecord = Record<string, unknown>;
+
+function stringField(record: AgentRecord, key: string) {
+  const value = record[key];
+  return typeof value === "string" ? value : undefined;
+}
+
+function numberField(record: AgentRecord, key: string) {
+  const value = record[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+function objectField(record: AgentRecord, key: string): Record<string, unknown> | undefined {
+  const value = record[key];
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : undefined;
+}
+
+function localWorkspaceModeField(record: AgentRecord): "current" | "task-worktree" | undefined {
+  const directValue = stringField(record, "localWorkspaceMode");
+  const runtimeBinding = objectField(record, "runtimeBinding");
+  const runtimeValue = typeof runtimeBinding?.localWorkspaceMode === "string"
+    ? runtimeBinding.localWorkspaceMode
+    : typeof runtimeBinding?.workspaceMode === "string"
+      ? runtimeBinding.workspaceMode
+      : undefined;
+  const value = directValue ?? runtimeValue;
+  return value === "task-worktree" || value === "current" ? value : undefined;
+}
+
+function appendUniqueStrings(values: string[], next: unknown) {
+  if (!Array.isArray(next)) return values;
+  for (const value of next) {
+    const toolName = typeof value === "string"
+      ? value
+      : value && typeof value === "object" && typeof (value as any).name === "string"
+        ? (value as any).name
+        : value && typeof value === "object" && typeof (value as any).function?.name === "string"
+          ? (value as any).function.name
+          : "";
+    if (toolName && !values.includes(toolName)) values.push(toolName);
+  }
+  return values;
+}
+
+function resolveAgentRuntimeToolNames(record: AgentRecord) {
+  const tools = appendUniqueStrings(
+    appendUniqueStrings([], record.toolNames),
+    record.tools,
+  );
+  return tools.length > 0 ? tools : undefined;
+}
+
+export function resolveAgentRuntimeConfigFromRecord(
+  key: string,
+  record: AgentRecord,
+): AgentRuntimeAgentConfig {
+  const name = stringField(record, "name");
+  const prompt = stringField(record, "prompt");
+  const model = stringField(record, "model");
+  const apiSource = stringField(record, "apiSource");
+  const cliProvider = stringField(record, "cliProvider");
+  const customProviderUrl = stringField(record, "customProviderUrl");
+  const provider = stringField(record, "provider") ?? stringField(record, "apiSource");
+  const toolNames = resolveAgentRuntimeToolNames(record);
+  const temperature = numberField(record, "temperature");
+  const topP = numberField(record, "top_p");
+  const frequencyPenalty = numberField(record, "frequency_penalty");
+  const presencePenalty = numberField(record, "presence_penalty");
+  const maxTokens = numberField(record, "max_tokens");
+  const reasoningEffort = stringField(record, "reasoning_effort");
+  const runtimeBinding = objectField(record, "runtimeBinding");
+  const localWorkspaceMode = localWorkspaceModeField(record);
+  const delegation = objectField(record, "delegation");
+  return {
+    key,
+    ...(name ? { name } : {}),
+    ...(prompt ? { prompt } : {}),
+    ...(model ? { model } : {}),
+    ...(provider ? { provider } : {}),
+    ...(apiSource ? { apiSource } : {}),
+    ...(cliProvider ? { cliProvider } : {}),
+    ...(customProviderUrl ? { customProviderUrl } : {}),
+    ...(toolNames ? { toolNames } : {}),
+    ...(temperature !== undefined ? { temperature } : {}),
+    ...(topP !== undefined ? { top_p: topP } : {}),
+    ...(frequencyPenalty !== undefined ? { frequency_penalty: frequencyPenalty } : {}),
+    ...(presencePenalty !== undefined ? { presence_penalty: presencePenalty } : {}),
+    ...(maxTokens !== undefined ? { max_tokens: maxTokens } : {}),
+    ...(reasoningEffort ? { reasoning_effort: reasoningEffort } : {}),
+    ...(runtimeBinding ? { runtimeBinding } : {}),
+    ...(localWorkspaceMode ? { localWorkspaceMode } : {}),
+    ...(delegation ? { delegation } : {}),
+    rawRecord: record,
+  };
+}

package/agent-runtime/agentRecordKeys.ts

@@ -0,0 +1,14 @@
+export function buildAgentRuntimeAgentLookupKeys(args: {
+  agentRef: string;
+  userId: string;
+}) {
+  return [
+    args.agentRef,
+    `agent-${args.userId}-${args.agentRef}`,
+    `cybot-${args.userId}-${args.agentRef}`,
+  ];
+}
+
+export function shouldFetchAgentRuntimeRecordRemotely(dbKey: string) {
+  return /^(agent|cybot)(-pub)?-/.test(dbKey);
+}

package/agent-runtime/dialogMessageRecord.ts

@@ -0,0 +1,16 @@
+import type { AgentRuntimeChatMessage } from "./types";
+
+type DialogMessageRecord = Record<string, any>;
+
+export function dialogMessageRecordToAgentRuntimeMessage(
+  record: DialogMessageRecord
+): AgentRuntimeChatMessage | null {
+  if (!record || typeof record !== "object") return null;
+  if (record.role !== "user" && record.role !== "assistant" && record.role !== "tool") return null;
+  return {
+    role: record.role,
+    content: record.content ?? null,
+    ...(typeof record.toolCallId === "string" ? { tool_call_id: record.toolCallId } : {}),
+    ...(Array.isArray(record.tool_calls) ? { tool_calls: record.tool_calls } : {}),
+  };
+}

package/agent-runtime/dialogWritePlan.ts

@@ -0,0 +1,130 @@
+import type {
+  AgentRuntimeChatMessage,
+  AgentRuntimeHost,
+} from "./types";
+import type { AgentRuntimeSaveTurnInput } from "./hostAdapter";
+
+type DialogRecord = Record<string, any>;
+type DialogWriteOp = {
+  type: "put";
+  key: string;
+  value: DialogRecord;
+};
+
+function extractLastUserText(messages: AgentRuntimeChatMessage[]) {
+  const lastUser = [...messages].reverse().find((message) => message.role === "user");
+  if (typeof lastUser?.content === "string") return lastUser.content;
+  if (Array.isArray(lastUser?.content)) {
+    return lastUser.content
+      .filter((part) => part.type === "text")
+      .map((part) => part.text)
+      .join(" ");
+  }
+  return "";
+}
+
+function resolveDialogTitle(args: {
+  existingDialog?: DialogRecord | null;
+  messages: AgentRuntimeChatMessage[];
+}) {
+  if (typeof args.existingDialog?.title === "string" && args.existingDialog.title.trim()) {
+    return args.existingDialog.title;
+  }
+  const lastUserText = extractLastUserText(args.messages).trim();
+  return lastUserText ? lastUserText.slice(0, 80) : "Local agent run";
+}
+
+function buildDialogMessageWriteOps(args: {
+  dialogId: string;
+  input: AgentRuntimeSaveTurnInput;
+  userId: string;
+  now: number;
+  nowIso: string;
+}): DialogWriteOp[] {
+  return args.input.messages
+    .filter((message) => message.role !== "system")
+    .map((message, index) => {
+      // Keep timestamp-prefix ordering for LevelDB range scans. Do not switch
+      // to opaque ids until dialog query/continuation callers are reviewed.
+      const id = `${args.now}-${String(index + 1).padStart(3, "0")}`;
+      const key = `dialog-${args.dialogId}-msg-${id}`;
+      return {
+        type: "put" as const,
+        key,
+        value: {
+          id,
+          dbKey: key,
+          dialogId: args.dialogId,
+          role: message.role,
+          content: message.content ?? "",
+          ...(message.role === "user" ? { userId: args.userId } : {}),
+          ...(message.role === "assistant" ? {
+            agentKey: args.input.agentKey,
+            cybotKey: args.input.agentKey,
+          } : {}),
+          ...(message.tool_call_id ? { toolCallId: message.tool_call_id } : {}),
+          ...(Array.isArray(message.tool_calls) ? { tool_calls: message.tool_calls } : {}),
+          ...(message.tool_result_metadata ? { metadata: message.tool_result_metadata } : {}),
+          createdAt: args.nowIso,
+        },
+      };
+    });
+}
+
+export function buildAgentRuntimeDialogWritePlan(args: {
+  input: AgentRuntimeSaveTurnInput;
+  userId: string;
+  now: number;
+  createId: () => string;
+  runtimeHost: AgentRuntimeHost;
+  runtimeMetadata?: Record<string, unknown>;
+  existingDialog?: DialogRecord | null;
+}): { dialogId: string; ops: DialogWriteOp[] } {
+  const dialogId = args.input.continueDialogId || args.createId();
+  const nowIso = new Date(args.now).toISOString();
+  const dialogKey = `dialog-${args.userId}-${dialogId}`;
+  const dialogRecord = {
+    ...(args.existingDialog && typeof args.existingDialog === "object" ? args.existingDialog : {}),
+    id: dialogId,
+    dbKey: dialogKey,
+    type: "dialog",
+    userId: args.userId,
+    cybots: [args.input.agentKey],
+    primaryAgentKey: args.input.agentKey,
+    title: resolveDialogTitle({
+      existingDialog: args.existingDialog,
+      messages: args.input.messages,
+    }),
+    status: "done",
+    triggerType: `${args.runtimeHost}-local`,
+    executionMode: "foreground",
+    createdAt: args.existingDialog?.createdAt ?? nowIso,
+    updatedAt: nowIso,
+    finishedAt: args.now,
+    usage: args.input.result.usage,
+    ...(typeof args.input.result.toolCallCount === "number"
+      ? { toolCallCount: args.input.result.toolCallCount }
+      : {}),
+    localRuntime: {
+      host: args.runtimeHost,
+      ...(args.runtimeMetadata ?? {}),
+    },
+  };
+  return {
+    dialogId,
+    ops: [
+      {
+        type: "put",
+        key: dialogKey,
+        value: dialogRecord,
+      },
+      ...buildDialogMessageWriteOps({
+        dialogId,
+        input: args.input,
+        userId: args.userId,
+        now: args.now,
+        nowIso,
+      }),
+    ],
+  };
+}

package/agent-runtime/hostAdapter.ts

@@ -10,7 +10,20 @@ export type AgentRuntimeAgentConfig = {
   prompt?: string;
   model?: string;
   provider?: string;
+  apiSource?: string;
+  cliProvider?: string;
+  customProviderUrl?: string;
   toolNames?: string[];
+  temperature?: number;
+  top_p?: number;
+  frequency_penalty?: number;
+  presence_penalty?: number;
+  max_tokens?: number;
+  reasoning_effort?: string;
+  runtimeBinding?: Record<string, unknown>;
+  localWorkspaceMode?: "current" | "task-worktree";
+  delegation?: Record<string, unknown>;
+  rawRecord?: Record<string, unknown>;
 };
 
 export type AgentRuntimeProvider = {

package/agent-runtime/hybridRecordStore.ts

@@ -0,0 +1,147 @@
+export type HybridRecordKvDb = {
+  get(key: string): Promise<any>;
+  put(key: string, value: any): Promise<unknown>;
+  batch(ops: Array<{ type: "put"; key: string; value: any }>): Promise<unknown>;
+  iterator(options: { gte: string; lte?: string; lt?: string; reverse?: boolean; limit?: number }): AsyncIterable<[string, any]>;
+};
+
+export type HybridRecordStore = {
+  read(dbKey: string, options?: { preferredServerOrigin?: string | null; remote?: boolean }): Promise<any>;
+  write(dbKey: string, record: any): Promise<any>;
+  batch(ops: Array<{ type: "put"; key: string; value: any }>): Promise<unknown>;
+  iterator(options: { gte: string; lte?: string; lt?: string; reverse?: boolean; limit?: number }): AsyncIterable<[string, any]>;
+};
+
+type HybridRecordStoreDeps = {
+  db: HybridRecordKvDb;
+  defaultServer: string;
+  authToken?: string;
+  fetchImpl?: typeof fetch;
+};
+
+function normalizeHybridServer(value: string) {
+  return value.trim().replace(/\/+$/, "");
+}
+
+function resolveHybridServers(defaultServer: string, preferredServerOrigin?: string | null) {
+  const raw = [
+    preferredServerOrigin || "",
+    defaultServer,
+  ].filter((value) => value.trim().length > 0);
+  return [...new Set(raw.map(normalizeHybridServer))];
+}
+
+function normalizeHybridRecord(dbKey: string, record: any, serverOrigin?: string | null) {
+  if (!record || typeof record !== "object") return null;
+  return {
+    ...record,
+    dbKey: typeof record.dbKey === "string" && record.dbKey ? record.dbKey : dbKey,
+    ...(serverOrigin ? { serverOrigin } : {}),
+  };
+}
+
+function getHybridRecordTimestamp(record: any): number {
+  if (!record || typeof record !== "object") return 0;
+  const candidates = [
+    record.updatedAt,
+    record.updated_at,
+    record.createdAt,
+    record.created,
+    record?.meta?.createdAt,
+  ];
+  for (const candidate of candidates) {
+    if (typeof candidate === "number" && Number.isFinite(candidate) && candidate > 0) return candidate;
+    if (typeof candidate === "string" && candidate.trim()) {
+      const parsed = Date.parse(candidate);
+      if (Number.isFinite(parsed) && parsed > 0) return parsed;
+    }
+  }
+  return 0;
+}
+
+function isHybridTombstoneRecord(record: any): boolean {
+  if (!record || typeof record !== "object") return false;
+  if (typeof record.deletedAt === "string") return record.deletedAt.trim().length > 0;
+  return Boolean(record.deletedAt);
+}
+
+function shouldReplaceWithHybridRecord(nextRecord: any, currentRecord: any): boolean {
+  const nextTs = getHybridRecordTimestamp(nextRecord);
+  const currentTs = getHybridRecordTimestamp(currentRecord);
+  if (nextTs !== currentTs) return nextTs > currentTs;
+  return isHybridTombstoneRecord(nextRecord) && !isHybridTombstoneRecord(currentRecord);
+}
+
+async function readHybridLocalRecord(db: HybridRecordKvDb, dbKey: string) {
+  try {
+    return await db.get(dbKey);
+  } catch {
+    return null;
+  }
+}
+
+async function fetchHybridRemoteRecord(args: {
+  dbKey: string;
+  server: string;
+  authToken?: string;
+  fetchImpl: typeof fetch;
+}) {
+  const response = await args.fetchImpl(
+    `${args.server}/api/v1/db/read/${encodeURIComponent(args.dbKey)}`,
+    {
+      headers: {
+        "Content-Type": "application/json",
+        ...(args.authToken ? { Authorization: `Bearer ${args.authToken}` } : {}),
+      },
+    }
+  );
+  if (!response.ok) return null;
+  const payload = await response.json().catch(() => null);
+  return normalizeHybridRecord(args.dbKey, payload?.data ?? payload, args.server);
+}
+
+export function shouldCacheHybridRemoteRecord(remoteRecord: any, localRecord: any) {
+  if (!remoteRecord || typeof remoteRecord !== "object") return false;
+  if (!localRecord || typeof localRecord !== "object") return true;
+  return shouldReplaceWithHybridRecord(remoteRecord, localRecord);
+}
+
+export function createHybridRecordStore(
+  deps: HybridRecordStoreDeps
+): HybridRecordStore {
+  const fetchImpl = deps.fetchImpl ?? fetch;
+
+  return {
+    read: async (dbKey, options) => {
+      const localRecord = await readHybridLocalRecord(deps.db, dbKey);
+      if (localRecord) return { ...localRecord, dbKey };
+      if (options?.remote === false) return null;
+
+      for (const server of resolveHybridServers(deps.defaultServer, options?.preferredServerOrigin)) {
+        const remoteRecord = await fetchHybridRemoteRecord({
+          dbKey,
+          server,
+          authToken: deps.authToken,
+          fetchImpl,
+        });
+        if (!remoteRecord) continue;
+        if (shouldCacheHybridRemoteRecord(remoteRecord, localRecord)) {
+          await deps.db.put(dbKey, remoteRecord);
+        }
+        return remoteRecord;
+      }
+
+      return null;
+    },
+    write: async (dbKey, record) => {
+      const nextRecord = normalizeHybridRecord(dbKey, record) ?? { dbKey };
+      await deps.db.put(dbKey, nextRecord);
+      return nextRecord;
+    },
+    batch: async (ops) => deps.db.batch(ops.map((op) => ({
+      ...op,
+      value: normalizeHybridRecord(op.key, op.value) ?? { dbKey: op.key },
+    }))),
+    iterator: (options) => deps.db.iterator(options),
+  };
+}

package/agent-runtime/index.ts

@@ -2,8 +2,55 @@ export const AGENT_RUNTIME_PACKAGE_ID = "agent-runtime";
 
 export { createRuntimeHostDescriptor } from "./hostAdapter";
 export { runLocalAgentTurn } from "./localLoop";
+export {
+  pickAgentRuntimeInferenceOptions,
+} from "./agentConfigOptions";
+export {
+  buildOpenAiCompatibleChatCompletionRequest,
+  parseOpenAiCompatibleChatCompletionResponse,
+} from "./openAiCompatibleProvider";
+export { resolveOpenAiCompatibleProviderConfig } from "./openAiCompatibleProviderConfig";
+export {
+  buildPlatformChatCompletionRequest,
+  canUsePlatformChatProvider,
+  hasDirectOpenAiCompatibleProvider,
+  parsePlatformChatCompletionData,
+  parsePlatformChatCompletionResponse,
+  resolvePlatformChatProviderConfig,
+  shouldUsePlatformChatProvider,
+} from "./platformChatProvider";
 export { resolveAgentRuntimeDecision } from "./runtimeDecision";
 export { buildAgentRuntimeDecisionInput } from "./runtimeFacts";
+export {
+  buildAgentRuntimeAgentLookupKeys,
+  shouldFetchAgentRuntimeRecordRemotely,
+} from "./agentRecordKeys";
+export { resolveAgentRuntimeConfigFromRecord } from "./agentRecordConfig";
+export { dialogMessageRecordToAgentRuntimeMessage } from "./dialogMessageRecord";
+export { buildAgentRuntimeDialogWritePlan } from "./dialogWritePlan";
+export {
+  createHybridRecordStore,
+  shouldCacheHybridRemoteRecord,
+} from "./hybridRecordStore";
+export {
+  activateWorkspaceSession,
+  createWorkspaceSession,
+  formatWorkspaceSessionActivation,
+} from "./workspaceSession";
+export {
+  formatPreparedGitTaskWorkspace,
+  prepareGitTaskWorkspace,
+} from "./taskWorkspace";
+export {
+  executeLocalToolWithPolicy,
+  resolveLocalToolPolicy,
+} from "./localToolPolicy";
+export {
+  buildLocalWorkspaceOpenAiTools,
+  buildLocalWorkspacePolicyToolNames,
+  buildLocalWorkspaceToolset,
+  createLocalWorkspaceToolExecutors,
+} from "./localWorkspaceTools";
 export type {
   AgentRuntimeAgentConfig,
   AgentRuntimeHostAdapter,
@@ -16,6 +63,28 @@ export type {
   LocalAgentTurnInput,
   LocalAgentTurnResult,
 } from "./localLoop";
+export type {
+  HybridRecordKvDb,
+  HybridRecordStore,
+} from "./hybridRecordStore";
+export type {
+  PreparedTaskWorkspace,
+  PrepareTaskWorkspace,
+  WorkspaceSession,
+  WorkspaceSessionMode,
+} from "./workspaceSession";
+export type {
+  PreparedGitTaskWorkspace,
+} from "./taskWorkspace";
+export type {
+  LocalToolPolicyDecision,
+} from "./localToolPolicy";
+export type {
+  OpenAiCompatibleProviderConfig,
+} from "./openAiCompatibleProvider";
+export type {
+  PlatformChatProviderConfig,
+} from "./platformChatProvider";
 export type {
   AgentRuntimeChatMessage,
   AgentRuntimeDecision,

package/agent-runtime/localLoop.ts

@@ -13,12 +13,42 @@ export type LocalAgentTurnInput = {
   input: AgentRuntimeMessageContent;
   continueDialogId?: string;
   maxToolRounds?: number;
+  onToolEvent?: (event: LocalAgentToolEvent) => void;
 };
 
 export type LocalAgentTurnResult = AgentRuntimeResult & {
   dialogId: string;
 };
 
+export type LocalAgentToolEvent = {
+  type: "tool-call" | "tool-result" | "tool-error";
+  round: number;
+  toolCallId: string;
+  toolName: string;
+  message?: string;
+};
+
+const DEFAULT_LOCAL_AGENT_MAX_TOOL_ROUNDS = 16;
+
+function formatToolExecutionError(args: {
+  toolName: string;
+  error: unknown;
+}) {
+  const message = args.error instanceof Error ? args.error.message : String(args.error);
+  return `${args.toolName} failed: ${message}`;
+}
+
+function shouldReturnToolExecutionErrors(adapter: AgentRuntimeHostAdapter) {
+  return adapter.capabilities.includes("local-tools");
+}
+
+function emitToolEvent(
+  input: LocalAgentTurnInput,
+  event: LocalAgentToolEvent
+) {
+  input.onToolEvent?.(event);
+}
+
 function buildMessages(args: {
   prompt?: string;
   history: AgentRuntimeChatMessage[];
@@ -52,7 +82,7 @@ export async function runLocalAgentTurn(
     input: input.input,
   });
   const provider = await input.adapter.resolveProvider(agentConfig);
-  const maxToolRounds = input.maxToolRounds ?? 6;
+  const maxToolRounds = input.maxToolRounds ?? DEFAULT_LOCAL_AGENT_MAX_TOOL_ROUNDS;
   let toolCallCount = 0;
   let result: AgentRuntimeResult;
   for (let round = 0; round <= maxToolRounds; round += 1) {
@@ -66,14 +96,48 @@ export async function runLocalAgentTurn(
     messages.push({
       role: "assistant",
       content: result.content || null,
+      ...(result.reasoning_content ? { reasoning_content: result.reasoning_content } : {}),
       tool_calls: toolCalls,
     });
     for (const toolCall of toolCalls) {
-      const toolResult = await input.adapter.executeTool({
-        id: toolCall.id,
-        name: toolCall.function.name,
-        arguments: toolCall.function.arguments,
+      const toolName = toolCall.function.name;
+      let toolResult;
+      emitToolEvent(input, {
+        type: "tool-call",
+        round,
+        toolCallId: toolCall.id,
+        toolName,
       });
+      try {
+        toolResult = await input.adapter.executeTool({
+          id: toolCall.id,
+          name: toolName,
+          arguments: toolCall.function.arguments,
+        });
+        emitToolEvent(input, {
+          type: "tool-result",
+          round,
+          toolCallId: toolCall.id,
+          toolName,
+        });
+      } catch (error) {
+        if (!shouldReturnToolExecutionErrors(input.adapter)) throw error;
+        emitToolEvent(input, {
+          type: "tool-error",
+          round,
+          toolCallId: toolCall.id,
+          toolName,
+          message: error instanceof Error ? error.message : String(error),
+        });
+        toolResult = {
+          content: formatToolExecutionError({ toolName, error }),
+          metadata: {
+            error: true,
+            toolName,
+            message: error instanceof Error ? error.message : String(error),
+          },
+        };
+      }
       messages.push({
         role: "tool",
         content: toolResult.content,