nolo-cli 0.1.30 → 0.1.32

package/cli/client/localRuntimeAdapter.ts

@@ -0,0 +1,676 @@
+import type {
+  AgentRuntimeAgentConfig,
+  AgentRuntimeHostAdapter,
+  AgentRuntimeSaveTurnInput,
+} from "../agentRuntimeLocal";
+import { request as httpRequest } from "node:http";
+import { request as httpsRequest } from "node:https";
+import {
+  buildLocalWorkspacePolicyToolNames,
+  resolveLocalWorkspaceShellToolExposure,
+  buildLocalWorkspaceToolset,
+  buildLocalWorkspaceOpenAiTools,
+  buildOpenAiCompatibleChatCompletionRequest,
+  buildPlatformChatCompletionRequest,
+  createLocalWorkspaceToolExecutors,
+  parseOpenAiCompatibleChatCompletionResponse,
+  parsePlatformChatCompletionData,
+  parsePlatformChatCompletionResponse,
+  resolveHostRuntimeConfigFromEnv,
+  resolvePlatformChatProviderConfig,
+  resolveRequestedRuntimeToolNames,
+  shouldUsePlatformChatProvider,
+  type HostRuntimeConfig,
+} from "../agentRuntimeLocal";
+import type { AgentRuntimeChatMessage } from "../../agent-runtime";
+import { getDefaultCliLocalRuntimeDb } from "../localRuntimeDb";
+import { resolveAgentRuntimeConfigFromRecord } from "./agentConfigResolver";
+import { resolveCliOpenAiProviderConfig } from "./localProviderResolver";
+import {
+  buildLocalDialogWritePlan,
+  localDialogMessageRecordToRuntimeMessage,
+} from "./localDialogRecords";
+import {
+  buildLocalAgentLookupKeys,
+  shouldReadAgentKeyRemotely,
+} from "./localAgentRecords";
+import {
+  createCliHybridRecordStore,
+  type CliKvDb,
+  type HybridRecordStore,
+} from "./hybridRecordStore";
+import { executeLocalToolWithPolicy } from "./localToolPolicy";
+import { taskRunFunctionSchema } from "../../ai/tools/agent/taskRunTool";
+import { prepareTaskWorktree } from "./taskWorktree";
+import {
+  activateWorkspaceSession,
+  createWorkspaceSession,
+  formatWorkspaceSessionActivation,
+  type WorkspaceSession,
+} from "./workspaceSession";
+
+type EnvLike = Record<string, string | undefined>;
+type FetchInput = Parameters<typeof fetch>[0];
+type FetchInit = Parameters<typeof fetch>[1];
+type CliLocalRuntimeCliExecution = {
+  text: string;
+  raw?: string;
+  elapsed?: number;
+  warnings?: string[];
+};
+type CliLocalRuntimeCliExecutor = (
+  provider: string,
+  prompt: string,
+  options: {
+    model?: string;
+    timeout?: number;
+    cwd?: string;
+    yolo?: boolean;
+    env?: EnvLike;
+    systemPrompt?: string;
+    reasoningEffort?: "low" | "medium" | "high" | "xhigh" | "max";
+    temperature?: number;
+    topP?: number;
+    frequencyPenalty?: number;
+    maxTokens?: number;
+  }
+) => Promise<CliLocalRuntimeCliExecution>;
+const TRANSIENT_FETCH_MAX_ATTEMPTS = 8;
+const TRANSIENT_FETCH_RETRY_BASE_DELAY_MS = 250;
+
+export type CliLocalRuntimeDb = CliKvDb;
+
+export type CliLocalRuntimeAdapterDeps = {
+  env: EnvLike;
+  hostRuntimeConfig?: HostRuntimeConfig;
+  db?: CliLocalRuntimeDb;
+  store?: HybridRecordStore;
+  now?: () => number;
+  createId?: () => string;
+  fetchImpl?: typeof fetch;
+  cwd?: string;
+  output?: { write(chunk: string): unknown };
+  prepareTaskWorktree?: typeof prepareTaskWorktree;
+  localToolExecutors?: Record<string, (call: any) => Promise<{ content: string; metadata?: Record<string, unknown> }>>;
+  executeCli?: CliLocalRuntimeCliExecutor;
+  sleep?: (ms: number) => Promise<void>;
+  loopbackRequest?: (input: FetchInput, init?: FetchInit) => Promise<Response>;
+};
+
+async function defaultLocalRuntimeDb(): Promise<CliLocalRuntimeDb> {
+  return getDefaultCliLocalRuntimeDb();
+}
+
+async function defaultExecuteCli(
+  provider: string,
+  prompt: string,
+  options: Parameters<CliLocalRuntimeCliExecutor>[2]
+) {
+  const { executeCli } = await import("../../ai/agent/cliExecutor");
+  return executeCli(provider as any, prompt, options);
+}
+
+function createFallbackId() {
+  return `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 10)}`.toUpperCase();
+}
+
+function resolveLocalUserId(env: EnvLike) {
+  return env.NOLO_LOCAL_USER_ID || env.NOLO_USER_ID || "local";
+}
+
+function parseLocalToolBudgets(env: EnvLike) {
+  const raw = env.NOLO_LOCAL_TOOL_BUDGETS?.trim();
+  if (!raw) return {};
+  const budgets: Record<string, number> = {};
+  for (const part of raw.split(",")) {
+    const [name, value] = part.split("=").map((item) => item.trim());
+    const limit = Number(value);
+    if (name && Number.isFinite(limit) && limit >= 0) budgets[name] = Math.floor(limit);
+  }
+  return budgets;
+}
+
+function assertWithinLocalToolBudget(args: {
+  toolName: string;
+  budgets: Record<string, number>;
+  usage: Map<string, number>;
+}) {
+  const limit = args.budgets[args.toolName];
+  if (typeof limit !== "number") return;
+  const nextCount = (args.usage.get(args.toolName) ?? 0) + 1;
+  args.usage.set(args.toolName, nextCount);
+  if (nextCount <= limit) return;
+  throw new Error(
+    `${args.toolName} exceeded local tool budget ${limit}. Stop broad discovery; edit the narrowest likely file or report a blocker.`
+  );
+}
+
+function isTransientFetchError(error: unknown) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /certificate|handshake|network|socket|timed out|timeout|ECONNRESET/i.test(message);
+}
+
+async function defaultSleep(ms: number) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function transientFetchRetryDelayMs(attempt: number) {
+  return Math.min(attempt * TRANSIENT_FETCH_RETRY_BASE_DELAY_MS, 2_000);
+}
+
+function isLoopbackUrl(input: FetchInput) {
+  try {
+    const target = typeof input === "string" || input instanceof URL
+      ? new URL(String(input))
+      : new URL(input.url);
+    const hostname = target.hostname.toLowerCase();
+    return hostname === "127.0.0.1" || hostname === "localhost" || hostname === "::1";
+  } catch {
+    return false;
+  }
+}
+
+function toNodeRequestBody(body: FetchInit["body"]) {
+  if (typeof body === "string") return Buffer.from(body);
+  if (body instanceof Uint8Array) return Buffer.from(body);
+  if (body instanceof ArrayBuffer) return Buffer.from(body);
+  return null;
+}
+
+async function defaultLoopbackRequest(input: FetchInput, init?: FetchInit) {
+  const target = typeof input === "string" || input instanceof URL
+    ? new URL(String(input))
+    : new URL(input.url);
+  const headers = new Headers(init?.headers);
+  const body = toNodeRequestBody(init?.body);
+  if (body && !headers.has("Content-Length")) {
+    headers.set("Content-Length", String(body.byteLength));
+  }
+  return await new Promise<Response>((resolve, reject) => {
+    const requestImpl = target.protocol === "https:" ? httpsRequest : httpRequest;
+    const req = requestImpl(target, {
+      method: init?.method ?? "GET",
+      headers: Object.fromEntries(headers.entries()),
+    }, (res) => {
+      const chunks: Buffer[] = [];
+      res.on("data", (chunk) => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
+      res.on("end", () => {
+        resolve(new Response(Buffer.concat(chunks), {
+          status: res.statusCode ?? 500,
+          headers: res.headers as Record<string, string>,
+        }));
+      });
+    });
+    req.on("error", reject);
+    if (body) req.write(body);
+    req.end();
+  });
+}
+
+async function fetchWithTransientRetry(
+  fetchImpl: typeof fetch,
+  input: FetchInput,
+  init?: FetchInit,
+  options: {
+    sleep?: (ms: number) => Promise<void>;
+    loopbackRequest?: (input: FetchInput, init?: FetchInit) => Promise<Response>;
+  } = {}
+) {
+  let lastError: unknown;
+  for (let attempt = 1; attempt <= TRANSIENT_FETCH_MAX_ATTEMPTS; attempt += 1) {
+    try {
+      if (options.loopbackRequest && isLoopbackUrl(input)) {
+        return await options.loopbackRequest(input, init);
+      }
+      return await fetchImpl(input, init);
+    } catch (error) {
+      if (!isTransientFetchError(error)) throw error;
+      lastError = error;
+      if (attempt < TRANSIENT_FETCH_MAX_ATTEMPTS) {
+        await (options.sleep ?? defaultSleep)(transientFetchRetryDelayMs(attempt));
+      }
+    }
+  }
+  throw lastError;
+}
+
+function buildOpenAiTools(args: {
+  requestedToolNames?: string[];
+  platformToolNames?: string[];
+  hostRuntimeConfig: HostRuntimeConfig;
+}) {
+  const toolset = buildLocalWorkspaceToolsetForHost(args);
+  return [
+    ...buildLocalWorkspaceOpenAiTools({
+      toolNames: toolset.toolNames,
+      exposeShellTools: toolset.exposeShellTools,
+    }),
+    ...buildServerPlatformOpenAiTools({ toolNames: args.platformToolNames }),
+  ];
+}
+
+function buildLocalWorkspaceToolsetForHost(args: {
+  requestedToolNames?: string[];
+  hostRuntimeConfig: HostRuntimeConfig;
+}) {
+  const requestedToolNames = args.requestedToolNames ?? [];
+  const exposeShellTools = resolveLocalWorkspaceShellToolExposure({
+    declaredToolNames: requestedToolNames,
+    hostRuntimeConfig: args.hostRuntimeConfig,
+  });
+  const toolset = buildLocalWorkspaceToolset({
+    declaredToolNames: requestedToolNames,
+    exposeShellTools,
+  });
+  return toolset;
+}
+
+function buildLocalPolicyToolNames(args: {
+  requestedToolNames?: string[];
+  platformToolNames?: string[];
+  hostRuntimeConfig: HostRuntimeConfig;
+}) {
+  const exposeShellTools = resolveLocalWorkspaceShellToolExposure({
+    declaredToolNames: args.requestedToolNames,
+    hostRuntimeConfig: args.hostRuntimeConfig,
+  });
+  return [
+    ...buildLocalWorkspacePolicyToolNames({
+      declaredToolNames: args.requestedToolNames,
+      exposeShellTools,
+    }),
+    ...((args.platformToolNames ?? []).includes("taskRun") ? ["taskRun"] : []),
+  ];
+}
+
+function buildServerPlatformOpenAiTools(args: { toolNames?: string[] }) {
+  const toolNames = new Set(args.toolNames ?? []);
+  return [
+    ...(toolNames.has("taskRun")
+      ? [{
+          type: "function",
+          function: taskRunFunctionSchema,
+        }]
+      : []),
+  ];
+}
+
+function parseToolArguments(raw: string) {
+  try {
+    const parsed = JSON.parse(raw || "{}");
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function resolveRuntimeServerUrl(env: EnvLike) {
+  return (env.NOLO_SERVER_URL || env.NOLO_SERVER || env.BASE_URL || "").replace(/\/+$/, "");
+}
+
+function resolveRuntimeAuthToken(env: EnvLike) {
+  return env.AUTH_TOKEN || env.AUTH || env.NOLO_MACHINE_API_KEY || "";
+}
+
+function buildServerPlatformToolExecutors(args: {
+  env: EnvLike;
+  fetchImpl: typeof fetch;
+}) {
+  return {
+    taskRun: async (call: any) => {
+      const serverUrl = resolveRuntimeServerUrl(args.env);
+      const authToken = resolveRuntimeAuthToken(args.env);
+      if (!serverUrl) throw new Error("taskRun requires NOLO_SERVER_URL, NOLO_SERVER, or BASE_URL.");
+      if (!authToken) throw new Error("taskRun requires AUTH_TOKEN or NOLO_MACHINE_API_KEY.");
+      const response = await args.fetchImpl(`${serverUrl}/api/task-run`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${authToken}`,
+        },
+        body: JSON.stringify(parseToolArguments(call.arguments)),
+      });
+      const text = await response.text().catch(() => "");
+      if (!response.ok) {
+        throw new Error(`taskRun bridge failed: HTTP ${response.status} ${text.slice(0, 500)}`);
+      }
+      return {
+        content: text,
+        metadata: { serverPlatformTool: true },
+      };
+    },
+  };
+}
+
+function buildLocalToolExecutors(args: {
+  workspaceRoot: string;
+  env: EnvLike;
+  fetchImpl: typeof fetch;
+  localToolExecutors?: CliLocalRuntimeAdapterDeps["localToolExecutors"];
+}) {
+  return {
+    ...createLocalWorkspaceToolExecutors({ workspaceRoot: args.workspaceRoot }),
+    ...buildServerPlatformToolExecutors({
+      env: args.env,
+      fetchImpl: args.fetchImpl,
+    }),
+    ...(args.localToolExecutors ?? {}),
+  };
+}
+
+function readLocalWorkspaceMode(agentConfig: AgentRuntimeAgentConfig | null) {
+  if (agentConfig?.localWorkspaceMode === "task-worktree") return "task-worktree";
+  const runtimeBinding = agentConfig?.runtimeBinding;
+  const value = runtimeBinding?.localWorkspaceMode ?? runtimeBinding?.workspaceMode;
+  return value === "task-worktree" ? "task-worktree" : "current";
+}
+
+function extractRuntimeMessageText(content: AgentRuntimeChatMessage["content"]) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .filter((part): part is Extract<typeof part, { type: "text" }> => part?.type === "text")
+    .map((part) => part.text ?? "")
+    .join("");
+}
+
+function buildCliTaskPromptFromMessages(messages: AgentRuntimeChatMessage[]) {
+  const history = messages
+    .filter((message) => message.role === "user" || message.role === "assistant")
+    .map((message) => {
+      const text = extractRuntimeMessageText(message.content).trim();
+      if (!text) return null;
+      return `[${message.role === "user" ? "用户" : "助手"}]\n${text}`;
+    })
+    .filter((message): message is string => Boolean(message))
+    .slice(-6);
+
+  if (history.length === 0) return "";
+  if (history.length === 1 && history[0]?.startsWith("[用户]\n")) {
+    return history[0].slice("[用户]\n".length);
+  }
+  return `请基于以下最近对话继续完成当前任务。\n\n${history.join("\n\n")}`;
+}
+
+async function resolveStore(deps: CliLocalRuntimeAdapterDeps) {
+  if (deps.store) return deps.store;
+  return createCliHybridRecordStore({
+    db: deps.db ?? await defaultLocalRuntimeDb(),
+    env: deps.env,
+    fetchImpl: deps.fetchImpl,
+  });
+}
+
+async function readAgentFromStore(args: {
+  store: HybridRecordStore;
+  agentRef: string;
+  userId: string;
+}): Promise<AgentRuntimeAgentConfig | null> {
+  for (const key of buildLocalAgentLookupKeys(args)) {
+    const record = await args.store.read(key, {
+      remote: shouldReadAgentKeyRemotely(key),
+    });
+    if (!record || typeof record !== "object") continue;
+    return resolveAgentRuntimeConfigFromRecord(key, record);
+  }
+  return null;
+}
+
+async function readDialogMessages(args: {
+  store: HybridRecordStore;
+  dialogId: string;
+}) {
+  const messages: AgentRuntimeChatMessage[] = [];
+  const prefix = `dialog-${args.dialogId}-msg-`;
+  const iterator = args.store.iterator({ gte: prefix, lte: `${prefix}\uffff` });
+  for await (const [, value] of iterator) {
+    const message = localDialogMessageRecordToRuntimeMessage(value);
+    if (message) messages.push(message);
+  }
+  return messages;
+}
+
+async function writeDialog(args: {
+  store: HybridRecordStore;
+  input: AgentRuntimeSaveTurnInput;
+  userId: string;
+  now: () => number;
+  createId: () => string;
+  cwd?: string;
+}) {
+  let existingDialog: any = null;
+  if (args.input.continueDialogId) {
+    const dialogKey = `dialog-${args.userId}-${args.input.continueDialogId}`;
+    existingDialog = await args.store.read(dialogKey);
+  }
+  const plan = buildLocalDialogWritePlan({
+    input: args.input,
+    userId: args.userId,
+    now: args.now(),
+    createId: args.createId,
+    existingDialog,
+    cwd: args.cwd,
+  });
+  await args.store.batch(plan.ops);
+  return { dialogId: plan.dialogId };
+}
+
+export function createCliLocalRuntimeAdapter(
+  deps: CliLocalRuntimeAdapterDeps
+): AgentRuntimeHostAdapter {
+  const now = deps.now ?? Date.now;
+  const createId = deps.createId ?? createFallbackId;
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const loopbackRequest = deps.loopbackRequest ?? (deps.fetchImpl ? undefined : defaultLoopbackRequest);
+  const executeCli = deps.executeCli ?? defaultExecuteCli;
+  const userId = resolveLocalUserId(deps.env);
+  const hostRuntimeConfig = deps.hostRuntimeConfig ?? resolveHostRuntimeConfigFromEnv({
+    env: deps.env,
+    surface: "cli-local",
+    workspaceBinding: "explicit-cwd",
+  });
+  const localToolBudgets = parseLocalToolBudgets(deps.env);
+  const localToolUsage = new Map<string, number>();
+  let activeAgentToolNames: string[] = [];
+  let workspaceSession: WorkspaceSession = createWorkspaceSession(
+    hostRuntimeConfig.workspaceBinding === "default-cwd"
+      ? { defaultCwd: deps.cwd }
+      : { cwd: deps.cwd }
+  );
+  let localToolExecutors = buildLocalToolExecutors({
+    workspaceRoot: workspaceSession.workspaceRoot,
+    env: deps.env,
+    fetchImpl,
+    localToolExecutors: deps.localToolExecutors,
+  });
+
+  async function activateAgentWorkspaceSession(args: {
+    agentRef: string;
+    agentConfig: AgentRuntimeAgentConfig | null;
+  }) {
+    const previousWorkspaceRoot = workspaceSession.workspaceRoot;
+    workspaceSession = await activateWorkspaceSession(workspaceSession, {
+      agentKey: args.agentConfig?.key ?? args.agentRef,
+      mode: readLocalWorkspaceMode(args.agentConfig),
+      env: deps.env,
+      prepareTaskWorkspace: deps.prepareTaskWorktree,
+    });
+    if (workspaceSession.workspaceRoot === previousWorkspaceRoot) return;
+    localToolExecutors = buildLocalToolExecutors({
+      workspaceRoot: workspaceSession.workspaceRoot,
+      env: deps.env,
+      fetchImpl,
+      localToolExecutors: deps.localToolExecutors,
+    });
+    deps.output?.write(formatWorkspaceSessionActivation(workspaceSession));
+  }
+
+  return {
+    host: "cli",
+    capabilities: ["leveldb-agent-config", "local-provider", "leveldb-persistence", "local-tools"],
+    loadAgentConfig: async (agentRef) => {
+      const agentConfig = await readAgentFromStore({
+        agentRef,
+        store: await resolveStore(deps),
+        userId,
+      });
+      const requestedToolNames = agentConfig
+        ? resolveRequestedRuntimeToolNames({ agentConfig })
+        : [];
+      activeAgentToolNames = buildLocalPolicyToolNames({
+        requestedToolNames,
+        platformToolNames: agentConfig?.toolNames,
+        hostRuntimeConfig,
+      });
+      await activateAgentWorkspaceSession({ agentRef, agentConfig });
+      return agentConfig;
+    },
+    loadDialogHistory: async (dialogId) => readDialogMessages({
+      dialogId,
+      store: await resolveStore(deps),
+    }),
+    saveTurn: async (input) => writeDialog({
+      store: await resolveStore(deps),
+      input,
+      userId,
+      now,
+      createId,
+      cwd: workspaceSession.workspaceRoot,
+    }),
+    resolveProvider: async (agentConfig) => {
+      if (agentConfig.apiSource === "cli") {
+        const cliProvider = String(agentConfig.cliProvider || "copilot").trim() || "copilot";
+        return {
+          model: agentConfig.model || cliProvider,
+          complete: async (messages) => {
+            const [firstMessage, ...remainingMessages] = messages;
+            const systemPrompt = firstMessage?.role === "system"
+              ? extractRuntimeMessageText(firstMessage.content).trim()
+              : "";
+            const taskPrompt = buildCliTaskPromptFromMessages(
+              firstMessage?.role === "system" ? remainingMessages : messages
+            );
+            const result = await executeCli(cliProvider, taskPrompt, {
+              ...(agentConfig.model ? { model: agentConfig.model } : {}),
+              cwd: workspaceSession.workspaceRoot,
+              yolo: true,
+              env: deps.env,
+              ...(systemPrompt ? { systemPrompt } : {}),
+              ...(typeof agentConfig.reasoning_effort === "string"
+                ? { reasoningEffort: agentConfig.reasoning_effort as "low" | "medium" | "high" | "xhigh" | "max" }
+                : {}),
+              ...(typeof agentConfig.temperature === "number"
+                ? { temperature: agentConfig.temperature }
+                : {}),
+              ...(typeof agentConfig.top_p === "number" ? { topP: agentConfig.top_p } : {}),
+              ...(typeof agentConfig.frequency_penalty === "number"
+                ? { frequencyPenalty: agentConfig.frequency_penalty }
+                : {}),
+              ...(typeof agentConfig.max_tokens === "number"
+                ? { maxTokens: agentConfig.max_tokens }
+                : {}),
+            });
+            return {
+              content: result.text,
+              model: agentConfig.model || cliProvider,
+              provider: cliProvider,
+              trace: messages,
+            };
+          },
+        };
+      }
+
+      if (shouldUsePlatformChatProvider(deps.env, agentConfig)) {
+        const providerConfig = resolvePlatformChatProviderConfig({
+          agentConfig,
+          env: deps.env,
+        });
+        return {
+          model: providerConfig.model,
+          complete: async (messages) => {
+            const requestedToolNames = resolveRequestedRuntimeToolNames({ agentConfig });
+            const tools = buildOpenAiTools({
+              requestedToolNames,
+              platformToolNames: agentConfig.toolNames,
+              hostRuntimeConfig,
+            });
+            const request = buildPlatformChatCompletionRequest({
+              providerConfig,
+              messages,
+              tools,
+            });
+            const res = await fetchWithTransientRetry(fetchImpl, request.url, request.init, {
+              sleep: deps.sleep,
+              loopbackRequest,
+            });
+            const data = parsePlatformChatCompletionData(await res.text().catch(() => ""));
+            if (!res.ok) {
+              throw new Error(`platform provider failed: HTTP ${res.status} ${JSON.stringify(data)}`);
+            }
+            return parsePlatformChatCompletionResponse({
+              providerConfig,
+              data,
+              trace: messages,
+            });
+          },
+        };
+      }
+
+      const providerConfig = resolveCliOpenAiProviderConfig({
+        agentConfig,
+        env: deps.env,
+      });
+      return {
+        model: providerConfig.model,
+        complete: async (messages) => {
+          const requestedToolNames = resolveRequestedRuntimeToolNames({ agentConfig });
+          const tools = buildOpenAiTools({
+            requestedToolNames,
+            platformToolNames: agentConfig.toolNames,
+            hostRuntimeConfig,
+          });
+          const request = buildOpenAiCompatibleChatCompletionRequest({
+            providerConfig,
+            messages,
+            tools,
+          });
+          const res = await fetchWithTransientRetry(fetchImpl, request.url, request.init, {
+            sleep: deps.sleep,
+            loopbackRequest,
+          });
+          const data = await res.json().catch(() => ({}));
+          if (!res.ok) {
+            throw new Error(`local provider failed: HTTP ${res.status} ${JSON.stringify(data)}`);
+          }
+          return parseOpenAiCompatibleChatCompletionResponse({
+            providerConfig,
+            data,
+            trace: messages,
+          });
+        },
+      };
+    },
+    executeTool: async (call) => {
+      assertWithinLocalToolBudget({
+        toolName: call.name,
+        budgets: localToolBudgets,
+        usage: localToolUsage,
+      });
+      const result = await executeLocalToolWithPolicy({
+        env: deps.env,
+        hostRuntimeConfig,
+        agentToolNames: activeAgentToolNames,
+        call,
+        executors: localToolExecutors,
+      });
+      return {
+        ...result,
+        metadata: {
+          ...(result.metadata ?? {}),
+          workspaceRoot: workspaceSession.workspaceRoot,
+          workspaceKind: workspaceSession.kind,
+        },
+      };
+    },
+  };
+}

package/cli/client/localToolPolicy.ts

@@ -0,0 +1,8 @@
+export {
+  executeLocalToolWithPolicy,
+  resolveLocalToolPolicy,
+} from "../agentRuntimeLocal";
+
+export type {
+  LocalToolPolicyDecision,
+} from "../agentRuntimeLocal";