nolo-cli 0.33.0-alpha.18 → 0.33.0-alpha.19

package/{chunk-AWHJWUVD.js → chunk-JL2PUYVS.js}

@@ -13,7 +13,7 @@ import {
 } from "./chunk-CWMSB67P.js";
 import {
   runLlm
-} from "./chunk-5AQ5Q6ZE.js";
+} from "./chunk-XS543SNR.js";
 import {
   cleanupCliSessionForDialog
 } from "./chunk-FH7VUJN5.js";
@@ -3520,7 +3520,7 @@ var messageSlice = createSliceWithThunks({
             runtimeOptions: args.runtimeOptions
           });
           if (agentKeyToUse) {
-            const { streamAgentChatTurn } = await import("./agentSlice-EZJ2W4JB.js");
+            const { streamAgentChatTurn } = await import("./agentSlice-SZRRJ3ZX.js");
             await dispatch(
               streamAgentChatTurn({
                 agentKey: agentKeyToUse,
@@ -4779,7 +4779,7 @@ var deleteDialogThunk = async (payload, thunkApi) => {
   }
   if (isCurrentDialog) {
     await thunkApi.dispatch(resetMsgs());
-    const { clearPendingAttachments: clearPendingAttachments2 } = await import("./dialogSlice-Y57RVHZZ.js");
+    const { clearPendingAttachments: clearPendingAttachments2 } = await import("./dialogSlice-5R4O4377.js");
     dispatch(clearPendingAttachments2());
     clearWorkflow();
   }
@@ -4788,15 +4788,15 @@ var deleteDialogThunk = async (payload, thunkApi) => {
 
 // packages/chat/dialog/dialogSlice.ts
 var runCreateDialogAction = async (args, thunkApi) => {
-  const { createDialogAction } = await import("./createDialogAction-6E3BEQGM.js");
+  const { createDialogAction } = await import("./createDialogAction-3CJ2GXNO.js");
   return createDialogAction(args, thunkApi);
 };
 var runCreateAgentAutomationAction = async (args, thunkApi) => {
-  const { createAgentAutomationAction } = await import("./createAgentAutomationAction-GU3N7CWJ.js");
+  const { createAgentAutomationAction } = await import("./createAgentAutomationAction-72NNXELT.js");
   return createAgentAutomationAction(args, thunkApi);
 };
 var runUpdateDialogTitleAction = async (args, thunkApi) => {
-  const { updateDialogTitleAction } = await import("./updateDialogTitleAction-5ITPS25R.js");
+  const { updateDialogTitleAction } = await import("./updateDialogTitleAction-NQCOEOLF.js");
   return updateDialogTitleAction(args, thunkApi);
 };
 var runAddDialogAgentAction = async (args, thunkApi) => {
@@ -4820,7 +4820,7 @@ var runSetDialogExtraReferencesAction = async (args, thunkApi) => {
   return setDialogExtraReferencesAction(args, thunkApi);
 };
 var runHandleSendMessageAction = async (args, thunkApi) => {
-  const { handleSendMessageAction } = await import("./handleSendMessageAction-HK2OIE4N.js");
+  const { handleSendMessageAction } = await import("./handleSendMessageAction-CIFBZCI2.js");
   return handleSendMessageAction(args, thunkApi);
 };
 function clearDialogState() {
@@ -4833,7 +4833,7 @@ var createPageAndAddReference = createAsyncThunk(
   async (payload, { dispatch, getState, rejectWithValue }) => {
     const { slateData, jsonData, title, type, fileId, groupId, dialogKey } = payload;
     try {
-      const { createDocState } = await import("./docStore-A7I2ZFQB.js");
+      const { createDocState } = await import("./docStore-A4SRW2DJ.js");
       const pageKey = await createDocState(
         { slateData, title },
         { dispatch, getState }

package/{chunk-DFW73ZMB.js → chunk-LJGEEYGC.js}

@@ -1,7 +1,7 @@
 import {
   i18n_default,
   toolRegistry
-} from "./chunk-AQBJUKBP.js";
+} from "./chunk-7BNPRRDS.js";
 import {
   canonicalizeToolNames
 } from "./chunk-ZZ2MH7LE.js";

package/{chunk-ZOQTWQOA.js → chunk-LLKHGZME.js}

@@ -1,13 +1,13 @@
 import {
   createCliLocalRuntimeAdapter,
   summarizeEndpoint
-} from "./chunk-JALRRIVE.js";
+} from "./chunk-XTSVOICC.js";
 import {
   clipMultilineText
-} from "./chunk-AQBJUKBP.js";
+} from "./chunk-7BNPRRDS.js";
 import {
   runLocalAgentTurn
-} from "./chunk-ITESDS27.js";
+} from "./chunk-YH3FPBG6.js";
 import {
   resolveLocalRuntimeEnvFromPolicy
 } from "./chunk-RQFO3CAF.js";

package/{chunk-NXXNT43Y.js → chunk-PU47HKTF.js}

@@ -8,10 +8,10 @@ import {
   inlineImageUrlsForCustomProvider,
   prepareTools,
   shouldInlineImageUrlsForAgent
-} from "./chunk-DFW73ZMB.js";
+} from "./chunk-LJGEEYGC.js";
 import {
   performFetchRequest
-} from "./chunk-Z4OGZWYZ.js";
+} from "./chunk-37LDAHQN.js";
 import {
   createSSEParser,
   createToolRunId,
@@ -22,22 +22,22 @@ import {
   toolRunSetPending,
   toolRunStarted,
   toolRunSucceeded
-} from "./chunk-AQBJUKBP.js";
+} from "./chunk-7BNPRRDS.js";
 import {
   getCurrentSpaceId
-} from "./chunk-YW4YRQUH.js";
+} from "./chunk-2UDMTJOM.js";
 import {
   addToolMessage,
   messageStreamEnd,
   messageStreaming,
   updateToolMessage
-} from "./chunk-AWHJWUVD.js";
+} from "./chunk-JL2PUYVS.js";
 import {
   streamAgentChatTurn
-} from "./chunk-5AQ5Q6ZE.js";
+} from "./chunk-XS543SNR.js";
 import {
   EMPTY_ASSISTANT_REPAIR_PROMPT
-} from "./chunk-ITESDS27.js";
+} from "./chunk-YH3FPBG6.js";
 import {
   accumulateToolCallDelta,
   createThinkParserState,

package/{chunk-XV4KDZ5L.js → chunk-REOW4YJX.js}

@@ -30,7 +30,7 @@ import {
   spawnToWebStreams,
   truncateToolOutput,
   waitForNodeProcessExit
-} from "./chunk-ITESDS27.js";
+} from "./chunk-YH3FPBG6.js";
 import {
   createThinkParserState,
   createToolCallAccumulator,

package/{chunk-QZPRTYLL.js → chunk-RO3AEN3L.js}

@@ -1,11 +1,11 @@
 import {
   addContentToSpace
-} from "./chunk-YW4YRQUH.js";
+} from "./chunk-2UDMTJOM.js";
 import {
   prepareAndPersistMessage,
   uiAskChoiceFunc,
   uiAskChoiceFunctionSchema
-} from "./chunk-AWHJWUVD.js";
+} from "./chunk-JL2PUYVS.js";
 import {
   require_date_fns
 } from "./chunk-M76ECQRD.js";

package/{chunk-WXOIYS2X.js → chunk-SBPGB6TF.js}

@@ -1,6 +1,6 @@
 import {
   updateContentTitle
-} from "./chunk-YW4YRQUH.js";
+} from "./chunk-2UDMTJOM.js";
 import {
   require_date_fns
 } from "./chunk-M76ECQRD.js";
@@ -367,7 +367,7 @@ async function saveDocState(arg, { dispatch, getState }) {
   }
 }
 async function createDocState(args, thunkApi) {
-  const { createPageAction } = await import("./createPageAction-OBDG5ZXM.js");
+  const { createPageAction } = await import("./createPageAction-HZHQGQO6.js");
   return createPageAction(args, thunkApi);
 }
 function subscribe(listener) {

package/{chunk-7VCY56GH.js → chunk-U2FRXKC7.js}

@@ -1,7 +1,7 @@
 import {
   fetchReferenceContents,
   resolveReferenceAssets
-} from "./chunk-Z4OGZWYZ.js";
+} from "./chunk-37LDAHQN.js";
 
 // packages/ai/agent/fetchAgentContexts.ts
 async function fetchAgentContexts(references, dispatch) {

package/{chunk-WAFMSVUX.js → chunk-V44VE7R4.js}

@@ -12,7 +12,7 @@ import {
 } from "./chunk-YDTYDA5W.js";
 import {
   clearCliLocalRuntimePreparedAgentCache
-} from "./chunk-JALRRIVE.js";
+} from "./chunk-XTSVOICC.js";
 import {
   resolveCliAgentKeyInput
 } from "./chunk-EKLRRZIN.js";

package/{chunk-5AQ5Q6ZE.js → chunk-XS543SNR.js}

@@ -304,7 +304,7 @@ var slice = createSliceWithThunks({
       const overrides = {};
       if (args.systemPromptOverride !== void 0) overrides.prompt = args.systemPromptOverride;
       if (args.toolsOverride !== void 0) overrides.tools = args.toolsOverride;
-      const { _executeModel } = await import("./_executeModel-2N36X5OJ.js");
+      const { _executeModel } = await import("./_executeModel-XKWVTZAY.js");
       return _executeModel(
         {
           isStreaming: args.isStreaming ?? false,
@@ -325,7 +325,7 @@ var slice = createSliceWithThunks({
      * - 循环直到无工具调用或触发其他运行时停止条件
      */
     runAgent: create.asyncThunk(async (args, thunkApi) => {
-      const { runAgentClientLoop } = await import("./runAgentClientLoop-FDNHKKGE.js");
+      const { runAgentClientLoop } = await import("./runAgentClientLoop-5I2R74NR.js");
       const { content: loopContent, toolCallCount } = await runAgentClientLoop(
         {
           agentKey: args.agentKey,
@@ -341,7 +341,7 @@ var slice = createSliceWithThunks({
      * 聊天轮次流式 Agent 调用
      */
     streamAgentChatTurn: create.asyncThunk(async (args, thunkApi) => {
-      const { streamAgentChatTurnHandler } = await import("./streamAgentChatTurn-2P5KBPCO.js");
+      const { streamAgentChatTurnHandler } = await import("./streamAgentChatTurn-UDYSE2ES.js");
       return streamAgentChatTurnHandler(args, thunkApi);
     }),
     /**

package/{chunk-JALRRIVE.js → chunk-XTSVOICC.js}

@@ -20,7 +20,7 @@ import {
 import {
   inlineImageUrlsForCustomProvider,
   prepareTools
-} from "./chunk-DFW73ZMB.js";
+} from "./chunk-LJGEEYGC.js";
 import {
   getServerProviderSecret
 } from "./chunk-HS7MLR74.js";
@@ -39,7 +39,7 @@ import {
   rememberMemoryFunctionSchema,
   resolveAgentRequiredPackIds,
   setTodoListFunc
-} from "./chunk-AQBJUKBP.js";
+} from "./chunk-7BNPRRDS.js";
 import {
   createDrainExhaustedResponse,
   isCoreDrainingBody,
@@ -55,13 +55,13 @@ import {
   prepareTokenUsageData,
   resolveBuiltinPlatformAgentConfig,
   runKeyed
-} from "./chunk-AWHJWUVD.js";
+} from "./chunk-JL2PUYVS.js";
 import {
   BUILTIN_TITLE_LLM_CONFIG
 } from "./chunk-RCFIB45Q.js";
 import {
   fetchServerSyncedCredential
-} from "./chunk-5AQ5Q6ZE.js";
+} from "./chunk-XS543SNR.js";
 import {
   require_date_fns
 } from "./chunk-M76ECQRD.js";
@@ -86,7 +86,7 @@ import {
   parseSyncServersEnv,
   resolveAgentNextAvailableAt,
   resolveOpenAiCompatibleProviderConfig
-} from "./chunk-XV4KDZ5L.js";
+} from "./chunk-REOW4YJX.js";
 import {
   buildPlatformChatCompletionRequest,
   canUsePlatformChatProvider,
@@ -105,7 +105,7 @@ import {
 import {
   resolveHistoricalToolContentCap,
   summarizeToolArguments
-} from "./chunk-ITESDS27.js";
+} from "./chunk-YH3FPBG6.js";
 import {
   convertMessagesToResponsesInput,
   toResponsesTools

package/{chunk-ITESDS27.js → chunk-YH3FPBG6.js}

@@ -1149,6 +1149,22 @@ ${stderr.trim()}` : "",
 }
 
 // packages/agent-runtime/capabilities/execShellCapability.ts
+function buildLocalExecShellContext(args) {
+  return {
+    workspaceRoot: args.workspaceRoot,
+    ...args.commandTimeoutMs !== void 0 ? { commandTimeoutMs: args.commandTimeoutMs } : {},
+    ...args.commandOutputLimit !== void 0 ? { commandOutputLimit: args.commandOutputLimit } : {},
+    ...args.commandPrefix ? { commandPrefix: args.commandPrefix } : {},
+    ...args.restrictToWorkspace !== void 0 ? { restrictToWorkspace: args.restrictToWorkspace } : {},
+    ...args.abortSignal ? { abortSignal: args.abortSignal } : {},
+    ...args.detachMs !== void 0 ? { detachMs: args.detachMs } : {},
+    ...args.confirmed !== void 0 ? { confirmed: args.confirmed } : {},
+    ...args.enableDestructiveShellGuard !== void 0 ? { enableDestructiveShellGuard: args.enableDestructiveShellGuard } : {},
+    ...args.confirmDestructiveAction ? { confirmDestructiveAction: args.confirmDestructiveAction } : {},
+    ...args.blockDestructiveWithoutConfirmation !== void 0 ? { blockDestructiveWithoutConfirmation: args.blockDestructiveWithoutConfirmation } : {},
+    ...args.onInvoke ? { onInvoke: args.onInvoke } : {}
+  };
+}
 function buildExecShellToolDefinition(toolName = "execShell") {
   return {
     type: "function",
@@ -1344,6 +1360,313 @@ async function evaluateCapabilityPolicy(capability, normalizedInput, ctx) {
   }
 }
 
+// packages/agent-runtime/capabilities/agentRunService.ts
+var activityCounter = 0;
+function generateActivityId(prefix = "act") {
+  activityCounter = (activityCounter + 1) % 1e6;
+  return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 7)}-${activityCounter}`;
+}
+function combineSignals(signals) {
+  const activeSignals = signals.filter((s) => Boolean(s));
+  if (activeSignals.length === 0) return void 0;
+  if (activeSignals.length === 1) return activeSignals[0];
+  if (typeof AbortSignal.any === "function") {
+    return AbortSignal.any(activeSignals);
+  }
+  const controller = new AbortController();
+  for (const s of activeSignals) {
+    if (s.aborted) {
+      controller.abort(s.reason);
+      return controller.signal;
+    }
+    s.addEventListener("abort", () => controller.abort(s.reason), { once: true });
+  }
+  return controller.signal;
+}
+async function executeAgentRunLifecycle(service, input, ctx = {}) {
+  const agentKey = input.agentKey ?? input.agentId;
+  if (!agentKey || typeof agentKey !== "string" || !agentKey.trim()) {
+    throw new Error("agents.run: \u7F3A\u5C11\u6709\u6548\u7684 agentId \u6216 agentKey\u3002");
+  }
+  if (!input.task || typeof input.task !== "string" || !input.task.trim()) {
+    throw new Error("agents.run: \u7F3A\u5C11\u6709\u6548\u7684 task \u6587\u672C\u63CF\u8FF0\u3002");
+  }
+  const effectiveSignal = combineSignals([input.signal, ctx.abortSignal]);
+  if (effectiveSignal?.aborted) {
+    const abortErr = new Error("Agent run was aborted before starting");
+    abortErr.name = "AbortError";
+    throw abortErr;
+  }
+  const activityId = generateActivityId("act-run");
+  const parentActivityId = input.parentActivityId ?? ctx.activityContext?.parentActivityId ?? ctx.parentActivityId;
+  const startedAt = Date.now();
+  const activity = {
+    activityId,
+    ...parentActivityId ? { parentActivityId } : {},
+    kind: "agent-run",
+    agentId: agentKey,
+    ...input.agentName ? { agentName: input.agentName } : {},
+    task: input.task,
+    status: "starting",
+    startedAt
+  };
+  const emit = async (type) => {
+    if (ctx.onActivity) {
+      try {
+        await ctx.onActivity({
+          type,
+          activity: { ...activity }
+        });
+      } catch {
+      }
+    }
+  };
+  await emit("activity-started");
+  let startResult;
+  try {
+    startResult = await service.start(
+      {
+        agentId: agentKey,
+        agentKey,
+        task: input.task,
+        input: input.input,
+        agentName: input.agentName,
+        ephemeral: input.ephemeral,
+        batchId: input.batchId,
+        parentActivityId,
+        signal: effectiveSignal
+      },
+      ctx
+    );
+  } catch (err) {
+    const errorMsg = err?.message || String(err);
+    const finishedAt2 = Date.now();
+    activity.status = "failed";
+    activity.finishedAt = finishedAt2;
+    activity.durationMs = finishedAt2 - startedAt;
+    activity.error = errorMsg;
+    await emit("activity-finished");
+    throw err;
+  }
+  const runId = startResult.runId;
+  activity.runId = runId;
+  if (startResult.status === "done" || startResult.status === "completed") {
+    const finishedAt2 = Date.now();
+    activity.status = "completed";
+    activity.finishedAt = finishedAt2;
+    activity.durationMs = finishedAt2 - startedAt;
+    activity.result = startResult.content;
+    await emit("activity-finished");
+    return {
+      runId,
+      status: "completed",
+      content: startResult.content ?? "",
+      activityId,
+      durationMs: activity.durationMs
+    };
+  }
+  if (startResult.status === "failed") {
+    const finishedAt2 = Date.now();
+    activity.status = "failed";
+    activity.finishedAt = finishedAt2;
+    activity.durationMs = finishedAt2 - startedAt;
+    activity.error = "Agent run start failed";
+    await emit("activity-finished");
+    throw new Error(`Agent run ${runId} failed on start.`);
+  }
+  activity.status = "running";
+  await emit("activity-updated");
+  let abortCleanup;
+  if (effectiveSignal && service.cancel) {
+    const onAbort = () => {
+      service.cancel?.({ runId, signal: effectiveSignal }, ctx).catch(() => {
+      });
+    };
+    if (effectiveSignal.aborted) {
+      onAbort();
+    } else {
+      effectiveSignal.addEventListener("abort", onAbort, { once: true });
+      abortCleanup = () => effectiveSignal.removeEventListener("abort", onAbort);
+    }
+  }
+  let waitResult;
+  try {
+    waitResult = await service.wait(
+      {
+        runId,
+        timeoutMs: input.timeoutMs ?? ctx.agentRunTimeoutMs,
+        signal: effectiveSignal
+      },
+      ctx
+    );
+  } catch (err) {
+    abortCleanup?.();
+    const errorMsg = err?.message || String(err);
+    const finishedAt2 = Date.now();
+    activity.status = effectiveSignal?.aborted ? "cancelled" : "failed";
+    activity.finishedAt = finishedAt2;
+    activity.durationMs = finishedAt2 - startedAt;
+    activity.error = errorMsg;
+    await emit("activity-finished");
+    throw err;
+  } finally {
+    abortCleanup?.();
+  }
+  const finishedAt = Date.now();
+  activity.finishedAt = finishedAt;
+  activity.durationMs = finishedAt - startedAt;
+  if (waitResult.status === "done" || waitResult.status === "completed") {
+    activity.status = "completed";
+    activity.result = waitResult.content;
+    await emit("activity-finished");
+    return {
+      runId,
+      status: "completed",
+      content: waitResult.content ?? "",
+      activityId,
+      durationMs: activity.durationMs,
+      raw: waitResult.raw
+    };
+  }
+  if (waitResult.status === "cancelled" || waitResult.status === "killed" || effectiveSignal?.aborted) {
+    activity.status = "cancelled";
+    await emit("activity-finished");
+    return {
+      runId,
+      status: "cancelled",
+      content: waitResult.content ?? "",
+      activityId,
+      durationMs: activity.durationMs,
+      raw: waitResult.raw
+    };
+  }
+  if (waitResult.status === "timeout") {
+    activity.status = "failed";
+    activity.error = "Agent run timed out";
+    if (service.cancel) {
+      service.cancel({ runId }, ctx).catch(() => {
+      });
+    }
+    await emit("activity-finished");
+    return {
+      runId,
+      status: "timeout",
+      content: waitResult.content ?? "",
+      activityId,
+      durationMs: activity.durationMs,
+      error: "Agent run timed out",
+      raw: waitResult.raw
+    };
+  }
+  activity.status = "failed";
+  activity.error = waitResult.errorMessage ?? `Agent run finished with status "${waitResult.status}"`;
+  await emit("activity-finished");
+  throw new Error(activity.error);
+}
+function createToolBridgeAgentRunService(options) {
+  return {
+    start: async (opts) => {
+      const res = await options.startRunner(opts);
+      const raw = res.rawData;
+      if (typeof raw === "string") {
+        return {
+          runId: generateActivityId("sync-run"),
+          status: "done",
+          content: raw
+        };
+      }
+      return {
+        runId: raw?.runId ?? generateActivityId("run"),
+        status: raw?.status ?? "pending",
+        agentKey: raw?.agentKey,
+        agentName: raw?.agentName,
+        batchId: raw?.batchId,
+        taskPreview: raw?.taskPreview,
+        content: raw?.content
+      };
+    },
+    wait: async (opts) => {
+      const res = await options.waitRunner(opts);
+      const raw = res.rawData;
+      return {
+        runId: raw?.runId ?? opts.runId,
+        status: raw?.status ?? "done",
+        content: typeof raw === "string" ? raw : raw?.content ?? res.displayData,
+        errorMessage: raw?.errorMessage ?? raw?.error,
+        raw
+      };
+    },
+    cancel: options.cancelRunner ? async (opts) => {
+      const res = await options.cancelRunner({ runId: opts.runId });
+      return {
+        runId: res.rawData?.runId ?? opts.runId,
+        status: res.rawData?.status ?? "cancelled",
+        wasActive: res.rawData?.wasActive
+      };
+    } : void 0,
+    inspect: options.inspectRunner ? async (opts) => {
+      const res = await options.inspectRunner({ runId: opts.runId, tailLines: opts.tailLines });
+      return {
+        runId: res.rawData?.runId ?? opts.runId,
+        found: res.rawData?.found ?? true,
+        status: res.rawData?.status,
+        logLines: res.rawData?.logLines
+      };
+    } : void 0
+  };
+}
+var toolCallSeq = 0;
+function createHostToolAgentRunService(hostExecuteTool) {
+  const execTool = async (name, args, opts) => {
+    const id = `sdk-${Date.now().toString(36)}-${(++toolCallSeq).toString(36)}`;
+    const res = await hostExecuteTool({ id, name, arguments: JSON.stringify(args) }, opts);
+    let rawData = res.content;
+    if (typeof res.content === "string" && res.content.length) {
+      try {
+        rawData = JSON.parse(res.content);
+      } catch {
+        rawData = res.content;
+      }
+    }
+    if (rawData && typeof rawData === "object" && typeof rawData.error === "string") {
+      throw new Error(rawData.error);
+    }
+    return {
+      rawData,
+      displayData: typeof res.metadata?.displayData === "string" ? res.metadata.displayData : String(res.content ?? "")
+    };
+  };
+  return createToolBridgeAgentRunService({
+    startRunner: async (opts) => execTool("startAgentRun", {
+      agentKey: opts.agentKey ?? opts.agentId,
+      task: opts.task,
+      input: opts.input,
+      agentName: opts.agentName,
+      ephemeral: opts.ephemeral,
+      batchId: opts.batchId,
+      parentDialogId: opts.parentDialogId,
+      wait: false
+    }),
+    waitRunner: async (opts) => execTool(
+      "controlAgentRun",
+      {
+        action: "wait",
+        runId: opts.runId,
+        timeoutMs: opts.timeoutMs
+      },
+      // Forward the per-run abort signal so the host wait loop can be
+      // cancelled (CLI controlAgentRun wait reads opts.abortSignal).
+      { abortSignal: opts.signal }
+    ),
+    cancelRunner: async ({ runId }) => execTool("controlAgentRun", { action: "stop", runId }),
+    inspectRunner: async ({ runId, tailLines }) => execTool("controlAgentRun", {
+      action: "status",
+      runId,
+      tailLines: tailLines ?? 0
+    })
+  });
+}
+
 // packages/agent-runtime/capabilities/capabilitySdk.ts
 var BUILTIN_CAPABILITIES = [
   execShellCapability
@@ -1360,6 +1683,31 @@ async function invokeCapability(capabilityOrName, input, ctx = {}) {
   }
   return capability.invoke(ctx, normalizedInput);
 }
+function createCapabilitySdk(args) {
+  const registry2 = /* @__PURE__ */ new Map();
+  for (const cap of args.capabilities ?? BUILTIN_CAPABILITIES) {
+    registry2.set(cap.name, cap);
+  }
+  const invoke = async (name, input) => {
+    const capability = registry2.get(name);
+    if (!capability) {
+      throw new Error(`Capability "${name}" not found.`);
+    }
+    return invokeCapability(capability, input, args.context);
+  };
+  return {
+    execShell: (input) => invoke("execShell", input),
+    agents: {
+      run: async (input) => {
+        if (!args.context.agentRunService) {
+          throw new Error("CapabilityExecutionContext missing agentRunService for agents.run()");
+        }
+        return executeAgentRunLifecycle(args.context.agentRunService, input, args.context);
+      }
+    },
+    invoke
+  };
+}
 
 // packages/agent-runtime/toolCallPairing.ts
 function readToolCallId(message) {
@@ -2338,6 +2686,18 @@ function applyPersistedTurnInput(messages, persistedInput, persistedInputReferen
     };
   });
 }
+function createLocalCapabilitySdk(adapter, execShellContext) {
+  return createCapabilitySdk({
+    context: {
+      agentRunService: createHostToolAgentRunService(adapter.executeTool),
+      // Inject the SAME local execution context the host uses for execShell,
+      // so PTC tools.execShell() is no more permissive than normal local tool
+      // calling. Caller supplies the real values (workspaceRoot, restrictToWorkspace,
+      // timeout/output limits, destructive-shell guard semantics, abortSignal).
+      ...execShellContext
+    }
+  });
+}
 async function runLocalAgentTurn(input) {
   const agentConfig = await input.adapter.loadAgentConfig(input.agentRef);
   if (!agentConfig) {
@@ -2348,6 +2708,22 @@ async function runLocalAgentTurn(input) {
     error.agentRef = input.agentRef;
     throw error;
   }
+  const execShellContext = buildLocalExecShellContext({
+    workspaceRoot: typeof input.runtimeContext?.workspaceRoot === "string" ? input.runtimeContext.workspaceRoot : typeof input.runtimeContext?.cwd === "string" ? input.runtimeContext.cwd : process.cwd(),
+    ...typeof input.runtimeContext?.restrictToWorkspace === "boolean" ? { restrictToWorkspace: input.runtimeContext.restrictToWorkspace } : typeof input.runtimeContext?.restrictShellToWorkspace === "boolean" ? { restrictToWorkspace: input.runtimeContext.restrictShellToWorkspace } : {},
+    ...typeof input.runtimeContext?.commandTimeoutMs === "number" ? { commandTimeoutMs: input.runtimeContext.commandTimeoutMs } : {},
+    ...typeof input.runtimeContext?.commandOutputLimit === "number" ? { commandOutputLimit: input.runtimeContext.commandOutputLimit } : {},
+    ...Array.isArray(input.runtimeContext?.commandPrefix) ? { commandPrefix: input.runtimeContext.commandPrefix } : {},
+    ...input.abortSignal ? { abortSignal: input.abortSignal } : {},
+    ...typeof input.runtimeContext?.detachMs === "number" ? { detachMs: input.runtimeContext.detachMs } : {},
+    ...typeof input.runtimeContext?.enableDestructiveShellGuard === "boolean" ? { enableDestructiveShellGuard: input.runtimeContext.enableDestructiveShellGuard } : {},
+    ...typeof input.runtimeContext?.confirmDestructiveAction === "function" ? { confirmDestructiveAction: input.runtimeContext.confirmDestructiveAction } : {},
+    ...typeof input.runtimeContext?.blockDestructiveWithoutConfirmation === "boolean" ? { blockDestructiveWithoutConfirmation: input.runtimeContext.blockDestructiveWithoutConfirmation } : {}
+  });
+  const tools = createLocalCapabilitySdk(input.adapter, execShellContext);
+  if (input.__testProgram) {
+    await input.__testProgram(tools);
+  }
   const rawBillingConfig = agentConfig.rawRecord ?? {};
   const billingConfig = {
     model: agentConfig.model || "unknown",