Method executeTool

packages/runtime/src/tool-runtime.ts:867–1629

(
    tool: MakaTool,
    turnId: string,
    queue: DurableSessionEventSink,
    args: unknown,
    ctx: {
      toolCallId: string;
      abortSignal: AbortSignal;
      providerOptions?: Record<string, unknown>;
      origin: 'provider' | 'code_mode';
      parentToolCallId?: string;
      parentOperationId?: string;
      maxResultBytes?: number;
    },
    stepId?: string,
  )

  }

  private async executeTool(
    tool: MakaTool,
    turnId: string,
    queue: DurableSessionEventSink,
    args: unknown,
    ctx: {
      toolCallId: string;
      abortSignal: AbortSignal;
      providerOptions?: Record<string, unknown>;
      origin: 'provider' | 'code_mode';
      parentToolCallId?: string;
      parentOperationId?: string;
      maxResultBytes?: number;
    },
    stepId?: string,
  ): Promise<unknown> {
    const rawExecutionArgs = snapshotToolArgs(args);
    const toolUseId = ctx.toolCallId;
    // Registration is synchronous and happens before the first await, so
    // parallel Runtime settlements cannot race past exclusive admission.
    const directOnlyFailure =
      ctx.origin === 'code_mode' && tool.nesting === 'direct_only'
        ? `Tool ${tool.name} is direct-only and cannot run inside exec.`
        : undefined;
    const admissionFailure = directOnlyFailure ?? this.admitToolForStep(tool, stepId);
    const executionArgs = rawExecutionArgs;
    let permissionArgs = executionArgs;
    let permissionArgsError: unknown;
    if (directOnlyFailure === undefined) {
      try {
        // A surface that cannot carry a sandbox-boundary request rejects the
        // operation before it interprets the requested expansion. Preserve that
        // availability contract even when an older caller sends a legacy shape.
        const sandboxBoundaryUnavailable =
          tool.name === 'request_sandbox_boundary' &&
          !this.interactionRun() &&
          (!this.input.createSandboxBoundaryRequest || !this.input.settleSandboxBoundaryRequest);
        if (!sandboxBoundaryUnavailable) {
          await validateDeclaredToolArgs(tool.parameters, rawExecutionArgs);
        }
        permissionArgs = tool.permissionArgs
          ? snapshotToolArgs(
              tool.permissionArgs(structuredClone(executionArgs) as never, {
                sessionId: this.input.sessionId,
                turnId,
                toolCallId: toolUseId,
              }),
            )
          : executionArgs;
      } catch (error) {
        permissionArgsError = error;
      }
    }
    // The args written into the `tool_start` event, the persisted `tool_call`
    // message and the durable ledger — that is, the record of the call the
    // model reads back on its next turn (`model-history.ts` replays
    // `event.content.args`).
    //