@ai-sdk/harness 0.0.0 → 1.0.0-canary.3

package/dist/agent/index.js

@@ -0,0 +1,2554 @@
+// src/errors/harness-capability-unsupported-error.ts
+import { AISDKError as AISDKError2 } from "@ai-sdk/provider";
+
+// src/errors/harness-error.ts
+import { AISDKError } from "@ai-sdk/provider";
+var name = "AI_HarnessError";
+var marker = `vercel.ai.error.${name}`;
+var symbol = Symbol.for(marker);
+var _a, _b;
+var HarnessError = class extends (_b = AISDKError, _a = symbol, _b) {
+  constructor({ message, cause }) {
+    super({ name, message, cause });
+    this[_a] = true;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker);
+  }
+};
+
+// src/errors/harness-capability-unsupported-error.ts
+var name2 = "AI_HarnessCapabilityUnsupportedError";
+var marker2 = `vercel.ai.error.${name2}`;
+var symbol2 = Symbol.for(marker2);
+var _a2, _b2;
+var HarnessCapabilityUnsupportedError = class extends (_b2 = HarnessError, _a2 = symbol2, _b2) {
+  constructor({
+    message,
+    harnessId,
+    cause
+  }) {
+    super({ message, cause });
+    this[_a2] = true;
+    Object.defineProperty(this, "name", { value: name2 });
+    this.harnessId = harnessId;
+  }
+  static isInstance(error) {
+    return AISDKError2.hasMarker(error, marker2);
+  }
+};
+
+// src/agent/harness-agent.ts
+import {
+  asSchema,
+  generateId as generateId5
+} from "@ai-sdk/provider-utils";
+
+// src/agent/internal/bridge-port-registry.ts
+var registries = /* @__PURE__ */ new WeakMap();
+function acquireBridgePort(options) {
+  let entry = registries.get(options.poolKey);
+  if (entry == null) {
+    entry = { pool: options.pool, leases: /* @__PURE__ */ new Map() };
+    registries.set(options.poolKey, entry);
+  }
+  const existing = entry.leases.get(options.sessionId);
+  if (existing != null) return existing;
+  const leased = new Set(entry.leases.values());
+  for (const port of entry.pool) {
+    if (!leased.has(port)) {
+      entry.leases.set(options.sessionId, port);
+      return port;
+    }
+  }
+  throw new Error(
+    `No available bridge port \u2014 pool of ${entry.pool.length} ports is fully leased.`
+  );
+}
+function releaseBridgePort(options) {
+  const entry = registries.get(options.poolKey);
+  if (entry == null) return;
+  entry.leases.delete(options.sessionId);
+}
+
+// src/agent/internal/resume-state-validation.ts
+import { safeValidateTypes } from "@ai-sdk/provider-utils";
+async function validateResumeStateData(input) {
+  const { harness, state } = input;
+  if (state.specificationVersion !== "harness-v1") {
+    throw new HarnessError({
+      message: `Resume state has unexpected specificationVersion '${state.specificationVersion}'; expected 'harness-v1'.`
+    });
+  }
+  if (state.harnessId !== harness.harnessId) {
+    throw new HarnessError({
+      message: `Resume state was produced by harness '${state.harnessId}' but this agent uses '${harness.harnessId}'.`
+    });
+  }
+  if (harness.resumeStateSchema == null) {
+    return state;
+  }
+  const result = await safeValidateTypes({
+    value: state.data,
+    schema: harness.resumeStateSchema
+  });
+  if (!result.success) {
+    throw new HarnessError({
+      message: `Resume state failed schema validation for harness '${harness.harnessId}': ${result.error.message}`,
+      cause: result.error
+    });
+  }
+  return {
+    harnessId: state.harnessId,
+    specificationVersion: state.specificationVersion,
+    data: result.value,
+    ...state.pendingToolApprovals !== void 0 ? { pendingToolApprovals: state.pendingToolApprovals } : {}
+  };
+}
+
+// src/agent/internal/to-harness-stream.ts
+async function toHarnessStream(options) {
+  let controller;
+  let closed = false;
+  const stream = new ReadableStream({
+    start(c) {
+      controller = c;
+    }
+  });
+  const safeEnqueue = (part) => {
+    if (closed) return;
+    controller.enqueue(part);
+  };
+  const safeClose = () => {
+    if (closed) return;
+    closed = true;
+    controller.close();
+  };
+  const control = await options.invoke(safeEnqueue);
+  Promise.resolve(control.done).then(
+    () => safeClose(),
+    (err) => {
+      safeEnqueue({ type: "error", error: err });
+      safeClose();
+    }
+  ).catch(() => {
+  });
+  return { stream, control };
+}
+
+// src/agent/internal/run-prompt.ts
+import {
+  executeTool,
+  generateId as generateId4,
+  isExecutableTool,
+  safeParseJSON
+} from "@ai-sdk/provider-utils";
+import { parseToolCall } from "ai/internal";
+
+// src/agent/internal/harness-stream-text-result.ts
+import {
+  DelayedPromise,
+  generateId
+} from "@ai-sdk/provider-utils";
+import {
+  addLanguageModelUsage,
+  asLanguageModelUsage,
+  createAsyncIterableStream,
+  createNullLanguageModelUsage,
+  DefaultStepResult,
+  toResponseMessages
+} from "ai/internal";
+import {
+  createUIMessageStreamResponse,
+  toUIMessageStream as toUIMessageStreamHelper
+} from "ai";
+var HarnessStreamTextResult = class {
+  constructor(options) {
+    // Delayed promises backing every PromiseLike accessor. Each is typed
+    // against the corresponding `StreamTextResult` property so the public
+    // surface stays in lockstep with AI SDK's interface as it evolves.
+    this._content = new DelayedPromise();
+    this._text = new DelayedPromise();
+    this._reasoning = new DelayedPromise();
+    this._reasoningText = new DelayedPromise();
+    this._files = new DelayedPromise();
+    this._sources = new DelayedPromise();
+    this._toolCalls = new DelayedPromise();
+    this._staticToolCalls = new DelayedPromise();
+    this._dynamicToolCalls = new DelayedPromise();
+    this._toolResults = new DelayedPromise();
+    this._staticToolResults = new DelayedPromise();
+    this._dynamicToolResults = new DelayedPromise();
+    this._finishReason = new DelayedPromise();
+    this._rawFinishReason = new DelayedPromise();
+    this._usage = new DelayedPromise();
+    this._warnings = new DelayedPromise();
+    this._steps = new DelayedPromise();
+    this._finalStep = new DelayedPromise();
+    this._request = new DelayedPromise();
+    this._response = new DelayedPromise();
+    this._responseMessages = new DelayedPromise();
+    this._providerMetadata = new DelayedPromise();
+    this.stepsBuffer = [];
+    this.currentStepContent = [];
+    this.currentStepWarnings = [];
+    this.stepNumber = 0;
+    // Accumulators that span the whole turn.
+    this.accumulatedUsage = createNullLanguageModelUsage();
+    this.finalProviderMetadata = void 0;
+    this.finalFinishReason = "other";
+    this.finalRawFinishReason = void 0;
+    this.aggregateWarnings = [];
+    this.settled = false;
+    this.tools = options.tools;
+    this.runtimeContext = options.runtimeContext;
+    this.toolsContext = options.toolsContext;
+    this.providerName = `harness:${options.harnessId}`;
+    this.modelId = options.sessionId;
+    let controllerRef;
+    const baseStream = new ReadableStream({
+      start(c) {
+        controllerRef = c;
+      }
+    });
+    this.fullStreamController = controllerRef;
+    const [forFull, forText] = baseStream.tee();
+    this.stream = forFull;
+    this.fullStream = this.stream;
+    this.textStream = forText.pipeThrough(
+      new TransformStream({
+        transform(part, controller) {
+          if (part.type === "text-delta") {
+            controller.enqueue(part.text);
+          }
+        }
+      })
+    );
+  }
+  // ─── Writer-side methods used by the driver ────────────────────────
+  /**
+   * Push a translated `TextStreamPart` into `fullStream` and accumulate it
+   * into the current step's content array where applicable.
+   */
+  enqueue(part) {
+    this.fullStreamController.enqueue(part);
+    this.appendToCurrentStepContent(part);
+  }
+  /**
+   * Mark the end of a step. Builds a `StepResult` from the accumulated
+   * content and records it in the steps array. Accepts the V4-shaped
+   * finish reason / usage the harness emits and normalizes to AI SDK's
+   * flat shape internally.
+   */
+  finishStep(input) {
+    const normalizedUsage = asLanguageModelUsage(input.usage);
+    const finishReason = input.finishReason.unified;
+    const rawFinishReason = input.finishReason.raw;
+    const step = new DefaultStepResult({
+      callId: generateId(),
+      stepNumber: this.stepNumber,
+      provider: this.providerName,
+      modelId: this.modelId,
+      runtimeContext: this.runtimeContext,
+      toolsContext: this.toolsContext,
+      content: this.currentStepContent,
+      finishReason,
+      rawFinishReason,
+      usage: normalizedUsage,
+      performance: createEmptyPerformance(),
+      warnings: input.warnings.length > 0 ? input.warnings : void 0,
+      request: {},
+      response: {
+        id: generateId(),
+        timestamp: /* @__PURE__ */ new Date(),
+        modelId: this.modelId,
+        messages: []
+      },
+      providerMetadata: input.providerMetadata
+    });
+    this.stepsBuffer.push(step);
+    this.fullStreamController.enqueue({
+      type: "finish-step",
+      finishReason,
+      rawFinishReason,
+      usage: normalizedUsage,
+      providerMetadata: input.providerMetadata,
+      response: step.response,
+      performance: createEmptyPerformance()
+    });
+    this.accumulatedUsage = addLanguageModelUsage(
+      this.accumulatedUsage,
+      normalizedUsage
+    );
+    this.finalFinishReason = finishReason;
+    this.finalRawFinishReason = rawFinishReason;
+    this.finalProviderMetadata = input.providerMetadata;
+    if (input.warnings.length > 0)
+      this.aggregateWarnings.push(...input.warnings);
+    this.stepNumber += 1;
+    this.currentStepContent = [];
+    this.currentStepWarnings = [];
+  }
+  /**
+   * Resolve every delayed promise and close `fullStream`. Idempotent.
+   */
+  async finish() {
+    if (this.settled) return;
+    this.settled = true;
+    if (this.currentStepContent.length > 0) {
+      const trailingStep = new DefaultStepResult({
+        callId: generateId(),
+        stepNumber: this.stepNumber,
+        provider: this.providerName,
+        modelId: this.modelId,
+        runtimeContext: this.runtimeContext,
+        toolsContext: this.toolsContext,
+        content: this.currentStepContent,
+        finishReason: this.finalFinishReason,
+        rawFinishReason: this.finalRawFinishReason,
+        usage: createNullLanguageModelUsage(),
+        performance: createEmptyPerformance(),
+        warnings: this.currentStepWarnings.length > 0 ? this.currentStepWarnings : void 0,
+        request: {},
+        response: {
+          id: generateId(),
+          timestamp: /* @__PURE__ */ new Date(),
+          modelId: this.modelId,
+          messages: []
+        },
+        providerMetadata: this.finalProviderMetadata
+      });
+      this.stepsBuffer.push(trailingStep);
+      this.currentStepContent = [];
+      this.currentStepWarnings = [];
+    }
+    const finalStep = this.stepsBuffer.length > 0 ? this.stepsBuffer[this.stepsBuffer.length - 1] : new DefaultStepResult({
+      callId: generateId(),
+      stepNumber: 0,
+      provider: this.providerName,
+      modelId: this.modelId,
+      runtimeContext: this.runtimeContext,
+      toolsContext: this.toolsContext,
+      content: [],
+      finishReason: this.finalFinishReason,
+      rawFinishReason: this.finalRawFinishReason,
+      usage: createNullLanguageModelUsage(),
+      performance: createEmptyPerformance(),
+      warnings: void 0,
+      request: {},
+      response: {
+        id: generateId(),
+        timestamp: /* @__PURE__ */ new Date(),
+        modelId: this.modelId,
+        messages: []
+      },
+      providerMetadata: void 0
+    });
+    const aggregatedContent = this.stepsBuffer.flatMap((s) => s.content);
+    this._content.resolve(
+      aggregatedContent
+    );
+    this._text.resolve(finalStep.text);
+    this._reasoning.resolve(
+      []
+    );
+    this._reasoningText.resolve(void 0);
+    this._files.resolve(this.stepsBuffer.flatMap((s) => s.files));
+    this._sources.resolve(this.stepsBuffer.flatMap((s) => s.sources));
+    this._toolCalls.resolve(
+      this.stepsBuffer.flatMap((s) => s.toolCalls)
+    );
+    this._staticToolCalls.resolve(
+      this.stepsBuffer.flatMap((s) => s.staticToolCalls)
+    );
+    this._dynamicToolCalls.resolve(
+      this.stepsBuffer.flatMap((s) => s.dynamicToolCalls)
+    );
+    this._toolResults.resolve(
+      this.stepsBuffer.flatMap((s) => s.toolResults)
+    );
+    this._staticToolResults.resolve(
+      this.stepsBuffer.flatMap((s) => s.staticToolResults)
+    );
+    this._dynamicToolResults.resolve(
+      this.stepsBuffer.flatMap((s) => s.dynamicToolResults)
+    );
+    this._finishReason.resolve(this.finalFinishReason);
+    this._rawFinishReason.resolve(this.finalRawFinishReason);
+    this._usage.resolve(this.accumulatedUsage);
+    this._warnings.resolve(
+      this.aggregateWarnings.length > 0 ? this.aggregateWarnings : void 0
+    );
+    this._steps.resolve(this.stepsBuffer);
+    this._finalStep.resolve(finalStep);
+    this._request.resolve(finalStep.request);
+    this._response.resolve(finalStep.response);
+    this._providerMetadata.resolve(this.finalProviderMetadata);
+    const responseMessages = await toResponseMessages({
+      content: aggregatedContent,
+      tools: this.tools
+    });
+    this._responseMessages.resolve(responseMessages);
+    this.fullStreamController.enqueue({
+      type: "finish",
+      finishReason: this.finalFinishReason,
+      rawFinishReason: this.finalRawFinishReason,
+      totalUsage: this.accumulatedUsage,
+      providerMetadata: this.finalProviderMetadata
+    });
+    this.fullStreamController.close();
+  }
+  /**
+   * Surface a fatal error as a stream `error` part + reject every delayed
+   * promise so awaiting consumers stop hanging. Idempotent.
+   */
+  fail(error) {
+    if (this.settled) return;
+    this.settled = true;
+    this.fullStreamController.enqueue({
+      type: "error",
+      error
+    });
+    this.fullStreamController.close();
+    for (const dp of [
+      this._content,
+      this._text,
+      this._reasoning,
+      this._reasoningText,
+      this._files,
+      this._sources,
+      this._toolCalls,
+      this._staticToolCalls,
+      this._dynamicToolCalls,
+      this._toolResults,
+      this._staticToolResults,
+      this._dynamicToolResults,
+      this._finishReason,
+      this._rawFinishReason,
+      this._usage,
+      this._warnings,
+      this._steps,
+      this._finalStep,
+      this._request,
+      this._response,
+      this._responseMessages,
+      this._providerMetadata
+    ]) {
+      try {
+        dp.reject(error);
+      } catch (e) {
+      }
+    }
+  }
+  // ─── Reader-side public surface (StreamTextResult contract) ────────
+  get content() {
+    return this._content.promise;
+  }
+  get text() {
+    return this._text.promise;
+  }
+  get reasoning() {
+    return this._reasoning.promise;
+  }
+  get reasoningText() {
+    return this._reasoningText.promise;
+  }
+  get files() {
+    return this._files.promise;
+  }
+  get sources() {
+    return this._sources.promise;
+  }
+  get toolCalls() {
+    return this._toolCalls.promise;
+  }
+  get staticToolCalls() {
+    return this._staticToolCalls.promise;
+  }
+  get dynamicToolCalls() {
+    return this._dynamicToolCalls.promise;
+  }
+  get toolResults() {
+    return this._toolResults.promise;
+  }
+  get staticToolResults() {
+    return this._staticToolResults.promise;
+  }
+  get dynamicToolResults() {
+    return this._dynamicToolResults.promise;
+  }
+  get finishReason() {
+    return this._finishReason.promise;
+  }
+  get rawFinishReason() {
+    return this._rawFinishReason.promise;
+  }
+  get usage() {
+    return this._usage.promise;
+  }
+  get totalUsage() {
+    return this._usage.promise;
+  }
+  get warnings() {
+    return this._warnings.promise;
+  }
+  get steps() {
+    return this._steps.promise;
+  }
+  get finalStep() {
+    return this._finalStep.promise;
+  }
+  get request() {
+    return this._request.promise;
+  }
+  get response() {
+    return this._response.promise;
+  }
+  get responseMessages() {
+    return this._responseMessages.promise;
+  }
+  get providerMetadata() {
+    return this._providerMetadata.promise;
+  }
+  // Output-specification surfaces are not yet supported.
+  get experimental_partialOutputStream() {
+    throw notSupportedYet("partial output stream");
+  }
+  get partialOutputStream() {
+    throw notSupportedYet("partial output stream");
+  }
+  get elementStream() {
+    throw notSupportedYet("element stream");
+  }
+  get output() {
+    throw notSupportedYet("structured output");
+  }
+  async consumeStream() {
+    const reader = this.fullStream.getReader();
+    try {
+      while (true) {
+        const { done } = await reader.read();
+        if (done) return;
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  toUIMessageStream({
+    originalMessages,
+    generateMessageId,
+    onFinish,
+    messageMetadata,
+    sendReasoning,
+    sendSources,
+    sendStart,
+    sendFinish,
+    onError
+  } = {}) {
+    return createAsyncIterableStream(
+      toUIMessageStreamHelper({
+        stream: this.stream,
+        tools: this.tools,
+        originalMessages,
+        generateMessageId,
+        onFinish,
+        messageMetadata,
+        sendReasoning,
+        sendSources,
+        sendStart,
+        sendFinish,
+        onError
+      })
+    );
+  }
+  pipeUIMessageStreamToResponse() {
+    throw notSupportedYet("pipeUIMessageStreamToResponse");
+  }
+  pipeTextStreamToResponse() {
+    throw notSupportedYet("pipeTextStreamToResponse");
+  }
+  toUIMessageStreamResponse({
+    originalMessages,
+    generateMessageId,
+    onFinish,
+    messageMetadata,
+    sendReasoning,
+    sendSources,
+    sendStart,
+    sendFinish,
+    onError,
+    ...init
+  } = {}) {
+    return createUIMessageStreamResponse({
+      stream: this.toUIMessageStream({
+        originalMessages,
+        generateMessageId,
+        onFinish,
+        messageMetadata,
+        sendReasoning,
+        sendSources,
+        sendStart,
+        sendFinish,
+        onError
+      }),
+      ...init
+    });
+  }
+  toTextStreamResponse() {
+    throw notSupportedYet("toTextStreamResponse");
+  }
+  // ─── Helpers ────────────────────────────────────────────────────────
+  appendToCurrentStepContent(part) {
+    switch (part.type) {
+      case "text-delta": {
+        const last = this.currentStepContent[this.currentStepContent.length - 1];
+        if (last && last.type === "text") {
+          last.text += part.text;
+        } else {
+          this.currentStepContent.push({
+            type: "text",
+            text: part.text
+          });
+        }
+        return;
+      }
+      case "tool-call":
+        this.currentStepContent.push({
+          ...part
+        });
+        return;
+      case "tool-approval-request":
+        this.currentStepContent.push({
+          ...part
+        });
+        return;
+      case "tool-approval-response":
+        this.currentStepContent.push({
+          ...part
+        });
+        return;
+      case "tool-result":
+        this.currentStepContent.push({
+          ...part
+        });
+        return;
+      default:
+        return;
+    }
+  }
+};
+function createEmptyPerformance() {
+  return {
+    effectiveOutputTokensPerSecond: 0,
+    outputTokensPerSecond: void 0,
+    inputTokensPerSecond: void 0,
+    effectiveTotalTokensPerSecond: 0,
+    stepTimeMs: 0,
+    responseTimeMs: 0,
+    toolExecutionMs: {},
+    timeToFirstOutputMs: void 0
+  };
+}
+function notSupportedYet(feature) {
+  return new Error(
+    `HarnessAgent: ${feature} is not implemented yet. Track the foundation review for follow-up.`
+  );
+}
+
+// src/agent/internal/translate-stream-part.ts
+import { generateId as generateId2 } from "@ai-sdk/provider-utils";
+function translateStreamPart(event) {
+  switch (event.type) {
+    case "stream-start":
+      return [];
+    case "text-start":
+      return [
+        {
+          type: "text-start",
+          id: event.id,
+          providerMetadata: event.harnessMetadata
+        }
+      ];
+    case "text-delta":
+      return [
+        {
+          type: "text-delta",
+          id: event.id,
+          text: event.delta,
+          providerMetadata: event.harnessMetadata
+        }
+      ];
+    case "text-end":
+      return [
+        {
+          type: "text-end",
+          id: event.id,
+          providerMetadata: event.harnessMetadata
+        }
+      ];
+    case "reasoning-start":
+      return [
+        {
+          type: "reasoning-start",
+          id: event.id,
+          providerMetadata: event.harnessMetadata
+        }
+      ];
+    case "reasoning-delta":
+      return [
+        {
+          type: "reasoning-delta",
+          id: event.id,
+          text: event.delta,
+          providerMetadata: event.harnessMetadata
+        }
+      ];
+    case "reasoning-end":
+      return [
+        {
+          type: "reasoning-end",
+          id: event.id,
+          providerMetadata: event.harnessMetadata
+        }
+      ];
+    case "tool-call":
+      return [];
+    case "tool-approval-request":
+      return [];
+    case "tool-result":
+      return [
+        {
+          type: "tool-result",
+          toolCallId: event.toolCallId,
+          toolName: event.toolName,
+          input: void 0,
+          output: event.result,
+          ...event.preliminary !== void 0 ? { preliminary: event.preliminary } : {},
+          ...event.providerMetadata !== void 0 ? { providerMetadata: event.providerMetadata } : {}
+        }
+      ];
+    case "file-change": {
+      const toolCallId = `harness-file-change-${generateId2()}`;
+      const payload = { event: event.event, path: event.path };
+      return [
+        {
+          type: "tool-call",
+          toolCallId,
+          toolName: "fileChange",
+          input: payload,
+          dynamic: true,
+          providerExecuted: true,
+          ...event.harnessMetadata !== void 0 ? { providerMetadata: event.harnessMetadata } : {}
+        },
+        {
+          type: "tool-result",
+          toolCallId,
+          toolName: "fileChange",
+          input: payload,
+          output: payload,
+          dynamic: true,
+          providerExecuted: true,
+          ...event.harnessMetadata !== void 0 ? { providerMetadata: event.harnessMetadata } : {}
+        }
+      ];
+    }
+    case "compaction": {
+      const toolCallId = `harness-compaction-${generateId2()}`;
+      const output = {
+        trigger: event.trigger,
+        summary: event.summary,
+        ...event.tokensBefore !== void 0 ? { tokensBefore: event.tokensBefore } : {},
+        ...event.tokensAfter !== void 0 ? { tokensAfter: event.tokensAfter } : {}
+      };
+      return [
+        {
+          type: "tool-call",
+          toolCallId,
+          toolName: "compaction",
+          input: {},
+          dynamic: true,
+          providerExecuted: true,
+          ...event.harnessMetadata !== void 0 ? { providerMetadata: event.harnessMetadata } : {}
+        },
+        {
+          type: "tool-result",
+          toolCallId,
+          toolName: "compaction",
+          input: {},
+          output,
+          dynamic: true,
+          providerExecuted: true,
+          ...event.harnessMetadata !== void 0 ? { providerMetadata: event.harnessMetadata } : {}
+        }
+      ];
+    }
+    case "error":
+      return [{ type: "error", error: event.error }];
+    case "raw":
+      return [
+        { type: "raw", rawValue: event.rawValue }
+      ];
+    case "finish-step":
+    case "finish":
+      return [];
+  }
+}
+
+// src/agent/internal/strip-work-dir.ts
+function stripWorkDir(part, sessionWorkDir) {
+  if (sessionWorkDir.length === 0) return part;
+  switch (part.type) {
+    case "tool-call":
+      return { ...part, input: stripString(part.input, sessionWorkDir) };
+    case "tool-result":
+      return {
+        ...part,
+        result: stripDeep(part.result, sessionWorkDir)
+      };
+    case "file-change":
+      return { ...part, path: stripString(part.path, sessionWorkDir) };
+    default:
+      return part;
+  }
+}
+function stripString(value, workDir) {
+  return value.split(`${workDir}/`).join("").split(workDir).join(".");
+}
+function stripDeep(value, workDir) {
+  if (typeof value === "string") return stripString(value, workDir);
+  if (Array.isArray(value)) return value.map((item) => stripDeep(item, workDir));
+  if (value !== null && typeof value === "object") {
+    const out = {};
+    for (const [key, val] of Object.entries(value)) {
+      out[key] = stripDeep(val, workDir);
+    }
+    return out;
+  }
+  return value;
+}
+
+// src/agent/internal/turn-telemetry.ts
+import { generateId as generateId3 } from "@ai-sdk/provider-utils";
+import { createTelemetryDispatcher } from "ai/internal";
+var NOOP = {
+  start() {
+  },
+  ensureStepOpen() {
+  },
+  stepFinish() {
+  },
+  toolStart() {
+  },
+  toolEnd() {
+  },
+  end() {
+  },
+  error() {
+  }
+};
+function createTurnTelemetry(opts) {
+  var _a3;
+  if (opts.telemetry == null) return NOOP;
+  const dispatcher = createTelemetryDispatcher({ telemetry: opts.telemetry });
+  const callId = generateId3();
+  const provider = opts.harnessId;
+  let modelId = (_a3 = opts.modelId) != null ? _a3 : "";
+  const runtimeContext = opts.runtimeContext;
+  const inputMessages = [
+    { role: "user", content: opts.promptText }
+  ];
+  let started = false;
+  let stepOpen = false;
+  let stepNumber = 0;
+  let ended = false;
+  const openTools = /* @__PURE__ */ new Map();
+  const cast = (event) => event;
+  const fireStart = () => {
+    var _a4;
+    if (started) return;
+    started = true;
+    (_a4 = dispatcher.onStart) == null ? void 0 : _a4.call(
+      dispatcher,
+      cast({
+        callId,
+        operationId: "ai.harness",
+        provider,
+        modelId,
+        tools: void 0,
+        toolChoice: void 0,
+        activeTools: void 0,
+        maxRetries: 0,
+        timeout: void 0,
+        headers: void 0,
+        providerOptions: void 0,
+        output: void 0,
+        toolsContext: void 0,
+        runtimeContext,
+        instructions: opts.instructions,
+        messages: inputMessages
+      })
+    );
+  };
+  const start = (overrideModelId) => {
+    if (started) return;
+    if (overrideModelId) modelId = overrideModelId;
+    fireStart();
+  };
+  const ensureStepOpen = () => {
+    var _a4, _b3;
+    if (!started) fireStart();
+    if (stepOpen || ended) return;
+    stepOpen = true;
+    (_a4 = dispatcher.onStepStart) == null ? void 0 : _a4.call(
+      dispatcher,
+      cast({
+        callId,
+        provider,
+        modelId,
+        stepNumber,
+        tools: void 0,
+        toolChoice: void 0,
+        activeTools: void 0,
+        steps: new Array(stepNumber),
+        providerOptions: void 0,
+        output: void 0,
+        runtimeContext,
+        messages: inputMessages
+      })
+    );
+    (_b3 = dispatcher.onLanguageModelCallStart) == null ? void 0 : _b3.call(
+      dispatcher,
+      cast({
+        callId,
+        provider,
+        modelId,
+        messages: inputMessages,
+        tools: void 0
+      })
+    );
+  };
+  const inferenceEnd = (info) => {
+    var _a4;
+    (_a4 = dispatcher.onLanguageModelCallEnd) == null ? void 0 : _a4.call(
+      dispatcher,
+      cast({
+        callId,
+        finishReason: info.finishReason,
+        responseId: callId,
+        usage: info.usage,
+        content: info.content
+      })
+    );
+  };
+  const closeOpenTools = () => {
+    var _a4;
+    for (const call of openTools.values()) {
+      (_a4 = dispatcher.onToolExecutionEnd) == null ? void 0 : _a4.call(
+        dispatcher,
+        cast({
+          callId,
+          toolExecutionMs: 0,
+          messages: [],
+          toolCall: {
+            type: "tool-call",
+            toolCallId: call.toolCallId,
+            toolName: call.toolName,
+            input: call.input,
+            dynamic: true
+          },
+          toolContext: void 0,
+          toolOutput: { type: "error", error: new Error("tool span unclosed") }
+        })
+      );
+    }
+    openTools.clear();
+  };
+  return {
+    start,
+    ensureStepOpen,
+    stepFinish(info) {
+      var _a4, _b3;
+      if (!stepOpen) return;
+      const content = (_a4 = info.content) != null ? _a4 : [];
+      closeOpenTools();
+      inferenceEnd({
+        finishReason: info.finishReason,
+        usage: info.usage,
+        content
+      });
+      (_b3 = dispatcher.onStepEnd) == null ? void 0 : _b3.call(
+        dispatcher,
+        cast({
+          callId,
+          finishReason: info.finishReason,
+          usage: info.usage,
+          providerMetadata: info.providerMetadata,
+          content,
+          response: {
+            id: callId,
+            modelId,
+            timestamp: /* @__PURE__ */ new Date(0),
+            messages: []
+          }
+        })
+      );
+      stepOpen = false;
+      stepNumber += 1;
+    },
+    toolStart(call) {
+      var _a4;
+      ensureStepOpen();
+      openTools.set(call.toolCallId, call);
+      (_a4 = dispatcher.onToolExecutionStart) == null ? void 0 : _a4.call(
+        dispatcher,
+        cast({
+          callId,
+          messages: [],
+          toolCall: {
+            type: "tool-call",
+            toolCallId: call.toolCallId,
+            toolName: call.toolName,
+            input: call.input,
+            dynamic: true
+          },
+          toolContext: void 0
+        })
+      );
+    },
+    toolEnd(toolCallId, output) {
+      var _a4;
+      const call = openTools.get(toolCallId);
+      if (call == null) return;
+      openTools.delete(toolCallId);
+      (_a4 = dispatcher.onToolExecutionEnd) == null ? void 0 : _a4.call(
+        dispatcher,
+        cast({
+          callId,
+          toolExecutionMs: 0,
+          messages: [],
+          toolCall: {
+            type: "tool-call",
+            toolCallId: call.toolCallId,
+            toolName: call.toolName,
+            input: call.input,
+            dynamic: true
+          },
+          toolContext: void 0,
+          toolOutput: output.ok ? { type: "tool-result", output: output.output } : { type: "error", error: output.error }
+        })
+      );
+    },
+    end(info) {
+      var _a4, _b3;
+      if (ended) return;
+      if (!started) fireStart();
+      if (stepOpen) {
+        closeOpenTools();
+        inferenceEnd({
+          finishReason: info.finishReason,
+          usage: info.usage,
+          content: []
+        });
+        (_a4 = dispatcher.onStepEnd) == null ? void 0 : _a4.call(
+          dispatcher,
+          cast({
+            callId,
+            finishReason: info.finishReason,
+            usage: info.usage,
+            providerMetadata: void 0,
+            content: [],
+            response: {
+              id: callId,
+              modelId,
+              timestamp: /* @__PURE__ */ new Date(0),
+              messages: []
+            }
+          })
+        );
+        stepOpen = false;
+      }
+      ended = true;
+      (_b3 = dispatcher.onEnd) == null ? void 0 : _b3.call(
+        dispatcher,
+        cast({
+          callId,
+          operationId: "ai.harness",
+          finishReason: info.finishReason,
+          usage: info.usage,
+          totalUsage: info.usage,
+          content: [],
+          steps: new Array(stepNumber),
+          response: {
+            id: callId,
+            modelId,
+            timestamp: /* @__PURE__ */ new Date(0),
+            messages: []
+          },
+          runtimeContext
+        })
+      );
+    },
+    error(err) {
+      var _a4;
+      if (ended) return;
+      if (!started) fireStart();
+      closeOpenTools();
+      ended = true;
+      (_a4 = dispatcher.onError) == null ? void 0 : _a4.call(dispatcher, err);
+    }
+  };
+}
+
+// src/agent/internal/permission-mode.ts
+var DEFAULT_PERMISSION_MODE = "allow-all";
+function resolvePermissionMode(input) {
+  var _a3;
+  return (_a3 = input.permissionMode) != null ? _a3 : DEFAULT_PERMISSION_MODE;
+}
+function permissionModeNeedsBuiltinSupport(input) {
+  return input.permissionMode !== "allow-all";
+}
+function resolveCustomToolApproval(input) {
+  var _a3;
+  const status = normalizeToolApprovalStatus({
+    status: (_a3 = input.toolApproval) == null ? void 0 : _a3[input.toolName]
+  });
+  switch (status.type) {
+    case "not-applicable":
+    case "approved":
+      return { type: "allow", reason: status.reason };
+    case "denied":
+      return { type: "deny", reason: status.reason };
+    case "user-approval":
+      return { type: "request" };
+  }
+}
+function normalizeToolApprovalStatus(input) {
+  if (input.status === void 0) return { type: "not-applicable" };
+  if (typeof input.status === "string") return { type: input.status };
+  return input.status;
+}
+
+// src/agent/internal/run-prompt.ts
+function runPrompt(input) {
+  var _a3, _b3, _c;
+  const result = new HarnessStreamTextResult({
+    tools: input.tools,
+    runtimeContext: input.runtimeContext,
+    // toolsContext is not configurable for harnesses; pass undefined cast.
+    toolsContext: void 0,
+    harnessId: input.harness.harnessId,
+    sessionId: input.session.sessionId
+  });
+  const pendingToolApprovals = (_a3 = input.pendingToolApprovals) != null ? _a3 : [];
+  const onPendingToolApproval = (_b3 = input.onPendingToolApproval) != null ? _b3 : (() => {
+  });
+  const onToolApprovalSettled = (_c = input.onToolApprovalSettled) != null ? _c : (() => {
+  });
+  const telemetry = createTurnTelemetry({
+    telemetry: input.telemetry,
+    harnessId: input.harness.harnessId,
+    modelId: input.session.modelId,
+    instructions: input.instructions,
+    promptText: input.prompt != null ? promptToText(input.prompt) : "",
+    runtimeContext: input.runtimeContext
+  });
+  const done = (async () => {
+    var _a4, _b4, _c2, _d, _e, _f;
+    let bridge;
+    try {
+      bridge = await toHarnessStream({
+        invoke: input.mode === "continue" ? (emit) => input.session.doContinueTurn({
+          tools: input.toolSpecs,
+          abortSignal: input.abortSignal,
+          emit
+        }) : (emit) => {
+          if (input.prompt == null) {
+            throw new Error(
+              'runPrompt: `prompt` is required for mode "prompt".'
+            );
+          }
+          return input.session.doPromptTurn({
+            prompt: input.prompt,
+            tools: input.toolSpecs,
+            instructions: input.instructions,
+            abortSignal: input.abortSignal,
+            emit
+          });
+        }
+      });
+    } catch (err) {
+      telemetry.error(err);
+      result.fail(err);
+      return;
+    }
+    const { stream, control } = bridge;
+    const reader = stream.getReader();
+    const toolCallsByToolCallId = /* @__PURE__ */ new Map();
+    const rawToolCallsByToolCallId = /* @__PURE__ */ new Map();
+    const pendingApprovalsByApprovalId = new Map(
+      pendingToolApprovals.map((approval) => [approval.approvalId, approval])
+    );
+    const pendingApprovalsByToolCallId = new Map(
+      pendingToolApprovals.map((approval) => [approval.toolCallId, approval])
+    );
+    const continuationsByApprovalId = new Map(
+      ((_a4 = input.toolApprovalContinuations) != null ? _a4 : []).map((continuation) => [
+        continuation.approvalResponse.approvalId,
+        continuation
+      ])
+    );
+    const settledApprovalToolCallIds = /* @__PURE__ */ new Set();
+    let stepText = "";
+    let stepReasoning = "";
+    let stepToolCalls = [];
+    const buildStepContent = () => {
+      const parts = [];
+      if (stepText) parts.push({ type: "text", text: stepText });
+      if (stepReasoning) parts.push({ type: "reasoning", text: stepReasoning });
+      parts.push(...stepToolCalls);
+      return parts;
+    };
+    const resetStepContent = () => {
+      stepText = "";
+      stepReasoning = "";
+      stepToolCalls = [];
+    };
+    const zeroUsage = {
+      inputTokens: {
+        total: void 0,
+        noCache: void 0,
+        cacheRead: void 0,
+        cacheWrite: void 0
+      },
+      outputTokens: {
+        total: void 0,
+        text: void 0,
+        reasoning: void 0
+      }
+    };
+    const toolCallsFinishReason = {
+      unified: "tool-calls",
+      raw: void 0
+    };
+    const finishForToolApprovalPause = async () => {
+      telemetry.stepFinish({
+        finishReason: toolCallsFinishReason,
+        usage: zeroUsage,
+        content: buildStepContent()
+      });
+      resetStepContent();
+      result.finishStep({
+        finishReason: toolCallsFinishReason,
+        usage: zeroUsage,
+        providerMetadata: void 0,
+        warnings: []
+      });
+      telemetry.end({
+        finishReason: toolCallsFinishReason,
+        usage: zeroUsage
+      });
+      await result.finish();
+    };
+    const enqueueApprovalRequest = (approval) => {
+      result.enqueue({
+        type: "tool-approval-request",
+        approvalId: approval.approvalId,
+        toolCall: approval.toolCall,
+        ...approval.isAutomatic !== void 0 ? { isAutomatic: approval.isAutomatic } : {}
+      });
+    };
+    const enqueueAutomaticApprovalResponse = (input2) => {
+      result.enqueue({
+        type: "tool-approval-response",
+        approvalId: input2.approvalId,
+        toolCall: input2.toolCall,
+        approved: input2.approved,
+        ...input2.reason !== void 0 ? { reason: input2.reason } : {},
+        ...input2.providerExecuted !== void 0 ? { providerExecuted: input2.providerExecuted } : {}
+      });
+    };
+    const enqueueApprovalResponse = (approval, continuation) => {
+      result.enqueue({
+        type: "tool-approval-response",
+        approvalId: approval.approvalId,
+        toolCall: continuation.toolCall,
+        approved: continuation.approvalResponse.approved,
+        ...continuation.approvalResponse.reason !== void 0 ? { reason: continuation.approvalResponse.reason } : {},
+        ...approval.providerExecuted !== void 0 ? { providerExecuted: approval.providerExecuted } : {}
+      });
+    };
+    const processPendingApprovalContinuation = async (approval, continuation) => {
+      var _a5;
+      enqueueApprovalResponse(approval, continuation);
+      onToolApprovalSettled(approval.approvalId);
+      pendingApprovalsByApprovalId.delete(approval.approvalId);
+      pendingApprovalsByToolCallId.delete(approval.toolCallId);
+      settledApprovalToolCallIds.add(approval.toolCallId);
+      if (approval.kind === "builtin") {
+        if (control.submitToolApproval == null) {
+          throw new Error(
+            `Harness '${input.harness.harnessId}' emitted a built-in tool approval request but does not support approval responses.`
+          );
+        }
+        await control.submitToolApproval({
+          approvalId: approval.approvalId,
+          approved: continuation.approvalResponse.approved,
+          reason: continuation.approvalResponse.reason
+        });
+        return;
+      }
+      if (!continuation.approvalResponse.approved) {
+        await control.submitToolResult({
+          toolCallId: approval.toolCallId,
+          output: {
+            type: "execution-denied",
+            reason: continuation.approvalResponse.reason
+          }
+        });
+        return;
+      }
+      const rawToolCall = (_a5 = rawToolCallsByToolCallId.get(approval.toolCallId)) != null ? _a5 : {
+        type: "tool-call",
+        toolCallId: approval.toolCallId,
+        toolName: approval.toolName,
+        input: approval.input
+      };
+      const outcome = await maybeExecuteHostTool({
+        event: rawToolCall,
+        tools: input.tools,
+        sandboxSession: input.sandboxSession,
+        abortSignal: input.abortSignal,
+        control,
+        onPreliminaryResult: (preliminaryOutput) => {
+          const stripped = stripWorkDir(
+            {
+              type: "tool-result",
+              toolCallId: rawToolCall.toolCallId,
+              toolName: rawToolCall.toolName,
+              result: preliminaryOutput
+            },
+            input.sessionWorkDir
+          );
+          result.enqueue({
+            type: "tool-result",
+            toolCallId: rawToolCall.toolCallId,
+            toolName: rawToolCall.toolName,
+            input: void 0,
+            output: stripped.result,
+            preliminary: true
+          });
+        }
+      });
+      telemetry.toolEnd(rawToolCall.toolCallId, outcome);
+    };
+    try {
+      for (const approval of pendingToolApprovals) {
+        const continuation = continuationsByApprovalId.get(approval.approvalId);
+        if (continuation != null) {
+          await processPendingApprovalContinuation(approval, continuation);
+        }
+      }
+      while (true) {
+        const { value, done: done2 } = await reader.read();
+        if (done2) break;
+        if (value == null) continue;
+        if (value.type === "stream-start") {
+          telemetry.start((_b4 = value.modelId) != null ? _b4 : input.session.modelId);
+        }
+        if (value.type !== "stream-start" && value.type !== "finish-step" && value.type !== "finish" && value.type !== "error") {
+          telemetry.ensureStepOpen();
+        }
+        const displayValue = stripWorkDir(value, input.sessionWorkDir);
+        const settledApprovalToolCallReplay = displayValue.type === "tool-call" && !displayValue.providerExecuted && settledApprovalToolCallIds.has(displayValue.toolCallId);
+        if (settledApprovalToolCallReplay) {
+          continue;
+        }
+        for (const part of translateStreamPart(displayValue)) {
+          result.enqueue(part);
+        }
+        if (displayValue.type === "tool-call") {
+          const parsed = await validateToolCall({
+            event: displayValue,
+            tools: input.tools
+          });
+          const parsedToolCall = asToolCallTextStreamPart({ part: parsed });
+          rawToolCallsByToolCallId.set(displayValue.toolCallId, displayValue);
+          toolCallsByToolCallId.set(displayValue.toolCallId, parsedToolCall);
+          result.enqueue(parsed);
+        }
+        if (value.type === "text-delta") {
+          stepText += value.delta;
+        } else if (value.type === "reasoning-delta") {
+          stepReasoning += value.delta;
+        }
+        if (value.type === "tool-call") {
+          stepToolCalls.push({
+            type: "tool-call",
+            toolCallId: value.toolCallId,
+            toolName: value.toolName,
+            input: value.input
+          });
+          telemetry.toolStart({
+            toolCallId: value.toolCallId,
+            toolName: value.toolName,
+            input: value.input
+          });
+        }
+        if (value.type === "tool-result") {
+          telemetry.toolEnd(
+            value.toolCallId,
+            value.isError ? { ok: false, error: value.result } : { ok: true, output: value.result }
+          );
+        }
+        if (value.type === "tool-approval-request") {
+          const toolCall = toolCallsByToolCallId.get(value.toolCallId);
+          if (toolCall == null) {
+            throw new Error(
+              `Harness '${input.harness.harnessId}' emitted approval request '${value.approvalId}' for unknown tool call '${value.toolCallId}'.`
+            );
+          }
+          const rawToolCall = rawToolCallsByToolCallId.get(value.toolCallId);
+          const pendingApproval = (_e = pendingApprovalsByApprovalId.get(value.approvalId)) != null ? _e : {
+            approvalId: value.approvalId,
+            toolCallId: value.toolCallId,
+            toolName: toolCall.toolName,
+            input: (_c2 = rawToolCall == null ? void 0 : rawToolCall.input) != null ? _c2 : JSON.stringify(toolCall.input),
+            kind: "builtin",
+            providerExecuted: (_d = rawToolCall == null ? void 0 : rawToolCall.providerExecuted) != null ? _d : true,
+            ...(rawToolCall == null ? void 0 : rawToolCall.nativeName) !== void 0 ? { nativeName: rawToolCall.nativeName } : {}
+          };
+          pendingApprovalsByApprovalId.set(
+            pendingApproval.approvalId,
+            pendingApproval
+          );
+          pendingApprovalsByToolCallId.set(
+            pendingApproval.toolCallId,
+            pendingApproval
+          );
+          const continuation = continuationsByApprovalId.get(
+            pendingApproval.approvalId
+          );
+          if (continuation != null) {
+            await processPendingApprovalContinuation(
+              pendingApproval,
+              continuation
+            );
+            continue;
+          }
+          onPendingToolApproval(pendingApproval);
+          enqueueApprovalRequest({
+            approvalId: pendingApproval.approvalId,
+            toolCall
+          });
+          await finishForToolApprovalPause();
+          return;
+        }
+        if (value.type === "finish-step") {
+          telemetry.stepFinish({
+            finishReason: value.finishReason,
+            usage: value.usage,
+            providerMetadata: value.harnessMetadata,
+            content: buildStepContent()
+          });
+          resetStepContent();
+          result.finishStep({
+            finishReason: value.finishReason,
+            usage: value.usage,
+            providerMetadata: value.harnessMetadata,
+            warnings: []
+          });
+        }
+        if (value.type === "finish") {
+          telemetry.end({
+            finishReason: value.finishReason,
+            usage: value.totalUsage
+          });
+        }
+        if (value.type === "tool-call" && !value.providerExecuted) {
+          const toolCall = value;
+          const parsedToolCall = toolCallsByToolCallId.get(toolCall.toolCallId);
+          if (parsedToolCall == null) {
+            throw new Error(
+              `Harness '${input.harness.harnessId}' could not find parsed tool call '${toolCall.toolCallId}' for custom tool approval.`
+            );
+          }
+          const customToolApprovalDecision = resolveCustomToolApproval({
+            toolName: toolCall.toolName,
+            toolApproval: input.toolApproval
+          });
+          if (customToolApprovalDecision.type === "deny") {
+            const approvalId = generateId4();
+            enqueueApprovalRequest({
+              approvalId,
+              toolCall: parsedToolCall,
+              isAutomatic: true
+            });
+            enqueueAutomaticApprovalResponse({
+              approvalId,
+              toolCall: parsedToolCall,
+              approved: false,
+              reason: customToolApprovalDecision.reason,
+              providerExecuted: false
+            });
+            const output = {
+              type: "execution-denied",
+              reason: customToolApprovalDecision.reason
+            };
+            await control.submitToolResult({
+              toolCallId: toolCall.toolCallId,
+              output
+            });
+            telemetry.toolEnd(toolCall.toolCallId, { ok: true, output });
+            continue;
+          }
+          const pendingApproval = (_f = pendingApprovalsByToolCallId.get(toolCall.toolCallId)) != null ? _f : customToolApprovalDecision.type === "request" ? {
+            approvalId: generateId4(),
+            toolCallId: toolCall.toolCallId,
+            toolName: toolCall.toolName,
+            input: toolCall.input,
+            kind: "custom",
+            providerExecuted: false,
+            ...toolCall.nativeName !== void 0 ? { nativeName: toolCall.nativeName } : {}
+          } : void 0;
+          if (pendingApproval != null) {
+            pendingApprovalsByApprovalId.set(
+              pendingApproval.approvalId,
+              pendingApproval
+            );
+            pendingApprovalsByToolCallId.set(
+              pendingApproval.toolCallId,
+              pendingApproval
+            );
+            const continuation = continuationsByApprovalId.get(
+              pendingApproval.approvalId
+            );
+            if (continuation != null) {
+              await processPendingApprovalContinuation(
+                pendingApproval,
+                continuation
+              );
+              continue;
+            }
+            const pendingParsedToolCall = toolCallsByToolCallId.get(
+              pendingApproval.toolCallId
+            );
+            if (pendingParsedToolCall == null) {
+              throw new Error(
+                `Harness '${input.harness.harnessId}' could not find parsed tool call '${pendingApproval.toolCallId}' for approval request '${pendingApproval.approvalId}'.`
+              );
+            }
+            onPendingToolApproval(pendingApproval);
+            enqueueApprovalRequest({
+              approvalId: pendingApproval.approvalId,
+              toolCall: pendingParsedToolCall
+            });
+            await finishForToolApprovalPause();
+            return;
+          }
+          const outcome = await maybeExecuteHostTool({
+            event: toolCall,
+            tools: input.tools,
+            sandboxSession: input.sandboxSession,
+            abortSignal: input.abortSignal,
+            control,
+            onPreliminaryResult: (preliminaryOutput) => {
+              const stripped = stripWorkDir(
+                {
+                  type: "tool-result",
+                  toolCallId: toolCall.toolCallId,
+                  toolName: toolCall.toolName,
+                  result: preliminaryOutput
+                },
+                input.sessionWorkDir
+              );
+              result.enqueue({
+                type: "tool-result",
+                toolCallId: toolCall.toolCallId,
+                toolName: toolCall.toolName,
+                input: void 0,
+                output: stripped.result,
+                preliminary: true
+              });
+            }
+          });
+          telemetry.toolEnd(toolCall.toolCallId, outcome);
+        }
+        if (value.type === "error") {
+          telemetry.error(value.error);
+          result.fail(value.error);
+          return;
+        }
+      }
+      await result.finish();
+    } catch (err) {
+      telemetry.error(err);
+      result.fail(err);
+    } finally {
+      reader.releaseLock();
+    }
+  })();
+  done.catch(() => {
+  });
+  return { result, done };
+}
+function asToolCallTextStreamPart(input) {
+  if (input.part.type !== "tool-call") {
+    throw new Error(
+      `Expected parsed tool-call stream part, got '${input.part.type}'.`
+    );
+  }
+  return input.part;
+}
+async function maybeExecuteHostTool(input) {
+  const tool = input.tools[input.event.toolName];
+  if (!isExecutableTool(tool)) return { ok: true, output: void 0 };
+  const parsed = await safeParseJSON({ text: input.event.input });
+  const args = parsed.success ? parsed.value : input.event.input;
+  try {
+    let output;
+    const stream = executeTool({
+      tool,
+      input: args,
+      options: {
+        toolCallId: input.event.toolCallId,
+        messages: [],
+        abortSignal: input.abortSignal,
+        context: void 0,
+        experimental_sandbox: input.sandboxSession
+      }
+    });
+    for await (const part of stream) {
+      if (part.type === "preliminary") {
+        input.onPreliminaryResult(part.output);
+      } else {
+        output = part.output;
+      }
+    }
+    await input.control.submitToolResult({
+      toolCallId: input.event.toolCallId,
+      output
+    });
+    return { ok: true, output };
+  } catch (err) {
+    await input.control.submitToolResult({
+      toolCallId: input.event.toolCallId,
+      output: { error: String(err) },
+      isError: true
+    });
+    return { ok: false, error: err };
+  }
+}
+async function validateToolCall(args) {
+  const { event, tools } = args;
+  const toolCall = {
+    type: "tool-call",
+    toolCallId: event.toolCallId,
+    toolName: event.toolName,
+    input: event.input,
+    ...event.providerExecuted !== void 0 ? { providerExecuted: event.providerExecuted } : {},
+    ...event.providerMetadata !== void 0 ? { providerMetadata: event.providerMetadata } : {}
+  };
+  const parsed = await parseToolCall({
+    toolCall,
+    tools,
+    repairToolCall: void 0,
+    refineToolInput: void 0,
+    instructions: void 0,
+    messages: []
+  });
+  return parsed;
+}
+function promptToText(prompt) {
+  if (typeof prompt === "string") return prompt;
+  const content = prompt.content;
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.filter(
+      (part) => typeof part === "object" && part != null && part.type === "text"
+    ).map((part) => part.text).join("");
+  }
+  return "";
+}
+
+// src/agent/harness-agent-session.ts
+var HarnessAgentSession = class {
+  constructor(options) {
+    this.pendingToolApprovals = /* @__PURE__ */ new Map();
+    this.stopped = false;
+    var _a3;
+    this.sessionId = options.sessionId;
+    this.harness = options.harness;
+    this.underlyingSession = options.underlyingSession;
+    this.sandboxSession = options.sandboxSession;
+    this.sandboxProvider = options.sandboxProvider;
+    this.leasedBridgePort = options.leasedBridgePort;
+    this.sessionWorkDir = options.sessionWorkDir;
+    this.toolApproval = options.toolApproval;
+    for (const approval of (_a3 = options.pendingToolApprovals) != null ? _a3 : []) {
+      this.pendingToolApprovals.set(approval.approvalId, approval);
+    }
+    this.isResume = options.underlyingSession.isResume;
+  }
+  /**
+   * Active network sandbox session.
+   *
+   * @internal — accessed by session turn and lifecycle drivers.
+   */
+  getSandboxSession() {
+    if (this.stopped || this.sandboxSession == null) {
+      throw new Error(
+        `Harness session ${this.sessionId} has ended and cannot be reused.`
+      );
+    }
+    return this.sandboxSession;
+  }
+  /**
+   * Working directory the agent runs in for this session. Used to strip the
+   * prefix from absolute paths in stream events before they reach consumers.
+   *
+   * @internal — accessed by session turn drivers.
+   */
+  getSessionWorkDir() {
+    return this.sessionWorkDir;
+  }
+  promptTurn(options) {
+    const session = this.requireReusableSession();
+    if (this.pendingToolApprovals.size > 0) {
+      throw new Error(
+        `Harness session ${this.sessionId} has pending tool approvals and must be continued with approval responses before accepting a new prompt.`
+      );
+    }
+    const sandboxSession = this.getSandboxSession();
+    return runPrompt({
+      harness: this.harness,
+      session,
+      prompt: options.prompt,
+      instructions: options.instructions,
+      tools: options.tools,
+      toolSpecs: options.toolSpecs,
+      sandboxSession: sandboxSession.restricted(),
+      sessionWorkDir: this.sessionWorkDir,
+      runtimeContext: options.runtimeContext,
+      abortSignal: options.abortSignal,
+      telemetry: options.telemetry,
+      toolApproval: this.toolApproval,
+      pendingToolApprovals: this.getPendingToolApprovals(),
+      onPendingToolApproval: (approval) => {
+        this.pendingToolApprovals.set(approval.approvalId, approval);
+      },
+      onToolApprovalSettled: (approvalId) => {
+        this.pendingToolApprovals.delete(approvalId);
+      }
+    });
+  }
+  continueTurn(options) {
+    const session = this.requireReusableSession();
+    const sandboxSession = this.getSandboxSession();
+    return runPrompt({
+      harness: this.harness,
+      session,
+      mode: "continue",
+      instructions: options.instructions,
+      tools: options.tools,
+      toolSpecs: options.toolSpecs,
+      sandboxSession: sandboxSession.restricted(),
+      sessionWorkDir: this.sessionWorkDir,
+      runtimeContext: options.runtimeContext,
+      abortSignal: options.abortSignal,
+      telemetry: options.telemetry,
+      toolApproval: this.toolApproval,
+      pendingToolApprovals: this.getPendingToolApprovals(),
+      toolApprovalContinuations: options.toolApprovalContinuations,
+      onPendingToolApproval: (approval) => {
+        this.pendingToolApprovals.set(approval.approvalId, approval);
+      },
+      onToolApprovalSettled: (approvalId) => {
+        this.pendingToolApprovals.delete(approvalId);
+      }
+    });
+  }
+  /**
+   * Ask the underlying runtime to compact its context. The runtime performs
+   * the compaction itself; when it completes, a `compaction` part appears on
+   * the active (or next) turn's stream. Safe to call between turns for
+   * runtimes whose compaction is session-scoped (e.g. Pi).
+   *
+   * Throws `HarnessCapabilityUnsupportedError` for harnesses that cannot
+   * trigger compaction manually (e.g. Codex, which still auto-compacts under
+   * the hood). Throws if the session has ended.
+   */
+  async compact(customInstructions) {
+    await this.requireReusableSession().doCompact(customInstructions);
+  }
+  /**
+   * Park the session, returning a payload the caller can persist and later
+   * pass to `agent.createSession({ sessionId, resumeFrom })` to reconnect.
+   * The runtime and sandbox keep running; this local session handle becomes
+   * unusable.
+   */
+  async detach() {
+    if (this.stopped || this.underlyingSession == null) {
+      throw new Error(
+        `Harness session ${this.sessionId} is not active and cannot be detached.`
+      );
+    }
+    const session = this.underlyingSession;
+    try {
+      const raw = await session.doDetach();
+      const validated = await validateResumeStateData({
+        harness: this.harness,
+        state: raw
+      });
+      return this.withPendingToolApprovals(validated);
+    } finally {
+      this.endLocalHandle({ releasePortLease: false });
+    }
+  }
+  /**
+   * Persist enough state to resume later, then stop the runtime and sandbox.
+   * Returns the resume state for a future
+   * `agent.createSession({ sessionId, resumeFrom })` call.
+   */
+  async stop() {
+    if (this.stopped || this.underlyingSession == null) {
+      throw new Error(
+        `Harness session ${this.sessionId} is not active and cannot be stopped.`
+      );
+    }
+    const session = this.underlyingSession;
+    const sandboxSession = this.getSandboxSession();
+    try {
+      const raw = await session.doStop();
+      const validated = await validateResumeStateData({
+        harness: this.harness,
+        state: raw
+      });
+      return this.withPendingToolApprovals(validated);
+    } finally {
+      this.endLocalHandle({ releasePortLease: true });
+      await Promise.resolve(sandboxSession.stop()).catch(() => {
+      });
+    }
+  }
+  /**
+   * Stop the runtime and discard resumability. The sandbox is destroyed when
+   * the provider supports destruction; otherwise it is stopped.
+   */
+  async destroy() {
+    var _a3, _b3;
+    if (this.stopped) return;
+    const session = this.underlyingSession;
+    const sandboxSession = this.getSandboxSession();
+    this.endLocalHandle({ releasePortLease: true });
+    if (session != null) {
+      await Promise.resolve(session.doDestroy()).catch(() => {
+      });
+    }
+    await Promise.resolve(
+      (_b3 = (_a3 = sandboxSession.destroy) == null ? void 0 : _a3.call(sandboxSession)) != null ? _b3 : sandboxSession.stop()
+    ).catch(() => {
+    });
+  }
+  /**
+   * Gracefully freeze the active turn at the slice boundary and return the
+   * resume payload, **leaving the sandbox/runtime running** so the next process
+   * can resume. Resolves once the in-flight `stream()`/`continueTurn()`
+   * has cleanly wound down at a precise cursor (see
+   * {@link HarnessV1Session.doSuspendTurn}).
+   *
+   * After this call the session is marked stopped. This in-process handle no
+   * longer drives turns; a future slice creates a fresh session from the
+   * returned state. The sandbox is **not** stopped and no port lease is
+   * released, because bridge-backed adapters may still have a live bridge on
+   * that port.
+   */
+  async suspendTurn() {
+    if (this.stopped || this.underlyingSession == null) {
+      throw new Error(
+        `Harness session ${this.sessionId} is not active and cannot be suspended.`
+      );
+    }
+    const session = this.underlyingSession;
+    const raw = await session.doSuspendTurn();
+    const validated = await validateResumeStateData({
+      harness: this.harness,
+      state: raw
+    });
+    this.stopped = true;
+    this.underlyingSession = void 0;
+    this.sandboxSession = void 0;
+    return this.withPendingToolApprovals(validated);
+  }
+  getPendingToolApprovals() {
+    return Array.from(this.pendingToolApprovals.values());
+  }
+  withPendingToolApprovals(state) {
+    const pendingToolApprovals = this.getPendingToolApprovals();
+    if (pendingToolApprovals.length === 0) {
+      return {
+        harnessId: state.harnessId,
+        specificationVersion: state.specificationVersion,
+        data: state.data
+      };
+    }
+    return {
+      ...state,
+      pendingToolApprovals
+    };
+  }
+  endLocalHandle(options) {
+    this.stopped = true;
+    this.underlyingSession = void 0;
+    this.sandboxSession = void 0;
+    if (options.releasePortLease) {
+      this.releasePortLease();
+    }
+  }
+  releasePortLease() {
+    if (this.leasedBridgePort == null) return;
+    releaseBridgePort({
+      poolKey: this.sandboxProvider,
+      sessionId: this.sessionId
+    });
+    this.leasedBridgePort = void 0;
+  }
+  requireReusableSession() {
+    if (this.stopped || this.underlyingSession == null) {
+      throw new Error(
+        `Harness session ${this.sessionId} has ended and cannot be reused.`
+      );
+    }
+    return this.underlyingSession;
+  }
+};
+
+// src/agent/harness-agent-tool-approval-continuation.ts
+function collectHarnessAgentToolApprovalContinuations(input) {
+  const lastMessage = input.messages.at(-1);
+  if ((lastMessage == null ? void 0 : lastMessage.role) !== "tool") return [];
+  const toolCallsByToolCallId = /* @__PURE__ */ new Map();
+  const approvalRequestsByApprovalId = /* @__PURE__ */ new Map();
+  for (const message of input.messages) {
+    if (message.role !== "assistant" || typeof message.content === "string") {
+      continue;
+    }
+    for (const part of message.content) {
+      if (part.type === "tool-call") {
+        toolCallsByToolCallId.set(part.toolCallId, {
+          type: "tool-call",
+          toolCallId: part.toolCallId,
+          toolName: part.toolName,
+          input: part.input,
+          ...part.providerExecuted !== void 0 ? { providerExecuted: part.providerExecuted } : {}
+        });
+      } else if (part.type === "tool-approval-request") {
+        approvalRequestsByApprovalId.set(part.approvalId, part);
+      }
+    }
+  }
+  const toolResultIds = /* @__PURE__ */ new Set();
+  for (const part of lastMessage.content) {
+    if (part.type === "tool-result") {
+      toolResultIds.add(part.toolCallId);
+    }
+  }
+  const continuations = [];
+  for (const part of lastMessage.content) {
+    if (part.type !== "tool-approval-response") continue;
+    const approvalRequest = approvalRequestsByApprovalId.get(part.approvalId);
+    if (approvalRequest == null) {
+      throw new HarnessError({
+        message: `Tool approval response '${part.approvalId}' does not match a prior tool approval request.`
+      });
+    }
+    if (toolResultIds.has(approvalRequest.toolCallId)) continue;
+    const toolCall = toolCallsByToolCallId.get(approvalRequest.toolCallId);
+    if (toolCall == null) {
+      throw new HarnessError({
+        message: `Tool approval request '${approvalRequest.approvalId}' references unknown tool call '${approvalRequest.toolCallId}'.`
+      });
+    }
+    continuations.push({
+      approvalResponse: part,
+      toolCall
+    });
+  }
+  return continuations;
+}
+
+// src/agent/internal/bootstrap-recipe.ts
+var BOOTSTRAP_SCHEMA_VERSION = 1;
+async function hashBootstrap(recipe) {
+  const encoder = new TextEncoder();
+  const chunks = [];
+  const pushString = (value) => {
+    chunks.push(encoder.encode(value));
+    chunks.push(encoder.encode("\0"));
+  };
+  pushString(recipe.harnessId);
+  pushString(recipe.bootstrapDir);
+  const sortedFiles = [...recipe.files].sort(
+    (a, b) => a.path.localeCompare(b.path)
+  );
+  for (const file of sortedFiles) {
+    pushString(file.path);
+    pushString(file.content);
+  }
+  pushString(JSON.stringify(recipe.commands));
+  pushString(String(BOOTSTRAP_SCHEMA_VERSION));
+  const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+  const buffer = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    buffer.set(chunk, offset);
+    offset += chunk.length;
+  }
+  const digest = await crypto.subtle.digest("SHA-256", buffer);
+  const bytes = new Uint8Array(digest);
+  let hex = "";
+  for (let i = 0; i < 8; i++) {
+    hex += bytes[i].toString(16).padStart(2, "0");
+  }
+  return hex;
+}
+function bootstrapMarkerPath(recipe, identity) {
+  return `${recipe.bootstrapDir}/.bootstrap-${identity}.ok`;
+}
+async function applyBootstrapRecipe(session, recipe, identity, options) {
+  const markerPath = bootstrapMarkerPath(recipe, identity);
+  const existingMarker = await session.readTextFile({
+    path: markerPath,
+    abortSignal: options == null ? void 0 : options.abortSignal
+  });
+  if (existingMarker !== null) {
+    return;
+  }
+  for (const file of recipe.files) {
+    await session.writeTextFile({
+      path: file.path,
+      content: file.content,
+      abortSignal: options == null ? void 0 : options.abortSignal
+    });
+  }
+  for (const cmd of recipe.commands) {
+    const result = await session.run({
+      command: cmd.command,
+      workingDirectory: cmd.workingDirectory,
+      abortSignal: options == null ? void 0 : options.abortSignal
+    });
+    if (result.exitCode !== 0) {
+      throw new Error(
+        `Bootstrap command failed for harness '${recipe.harnessId}' (exit ${result.exitCode}): ${cmd.command}
+${result.stderr || result.stdout}`
+      );
+    }
+  }
+  await session.writeTextFile({
+    path: markerPath,
+    content: "",
+    abortSignal: options == null ? void 0 : options.abortSignal
+  });
+}
+
+// src/agent/internal/resolve-observability.ts
+import { asArray } from "@ai-sdk/provider-utils";
+var ENV_TRUTHY = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
+function parseList(value) {
+  if (!value) return void 0;
+  const items = value.split(",").map((item) => item.trim()).filter(Boolean);
+  return items.length > 0 ? items : void 0;
+}
+function resolveDebugConfig(debug, env = process.env) {
+  var _a3, _b3, _c, _d;
+  const enabled = (_b3 = debug == null ? void 0 : debug.enabled) != null ? _b3 : ENV_TRUTHY.has(((_a3 = env.HARNESS_DEBUG) != null ? _a3 : "").toLowerCase());
+  const level = (_d = (_c = debug == null ? void 0 : debug.level) != null ? _c : env.HARNESS_DEBUG_LEVEL) != null ? _d : "debug";
+  const subsystems = (debug == null ? void 0 : debug.subsystems) ? [...debug.subsystems] : parseList(env.HARNESS_DEBUG_SUBSYSTEMS);
+  return { enabled, level, subsystems };
+}
+function toHarnessDiagnostic(d) {
+  return {
+    level: d.level,
+    message: d.message,
+    subsystem: d.subsystem,
+    kind: d.kind,
+    source: d.source,
+    stream: d.stream,
+    attrs: d.attrs,
+    error: d.error,
+    sessionId: d.sessionId,
+    timestamp: d.timestamp
+  };
+}
+function formatForStderr(d) {
+  var _a3;
+  const parts = [`[harness:${d.level}]`, d.subsystem, d.message].filter(
+    Boolean
+  );
+  let line = parts.join(" ");
+  if (d.error) {
+    line += ` (${(_a3 = d.error.name) != null ? _a3 : "Error"}: ${d.error.message})`;
+  }
+  return `${line}
+`;
+}
+function buildObservability(options) {
+  var _a3;
+  const resolved = resolveDebugConfig(options.settings.debug);
+  if (!resolved.enabled) return void 0;
+  const onLog = options.settings.onLog;
+  const integrations = ((_a3 = options.settings.telemetry) == null ? void 0 : _a3.integrations) ? asArray(options.settings.telemetry.integrations) : [];
+  const diagnosticConsumers = integrations.filter(
+    (integration) => typeof integration.ingestDiagnostic === "function"
+  );
+  const report = (emitted) => {
+    var _a4;
+    const diagnostic = toHarnessDiagnostic(emitted);
+    try {
+      process.stderr.write(formatForStderr(diagnostic));
+    } catch (e) {
+    }
+    onLog == null ? void 0 : onLog(diagnostic);
+    for (const consumer of diagnosticConsumers) {
+      (_a4 = consumer.ingestDiagnostic) == null ? void 0 : _a4.call(consumer, diagnostic);
+    }
+  };
+  return {
+    debug: {
+      enabled: true,
+      level: resolved.level,
+      ...resolved.subsystems ? { subsystems: resolved.subsystems } : {}
+    },
+    report
+  };
+}
+
+// src/agent/harness-agent.ts
+var HarnessAgent = class {
+  constructor(settings) {
+    this.version = "agent-v1";
+    var _a3;
+    this.settings = settings;
+    this.id = settings.id;
+    this.userTools = (_a3 = settings.tools) != null ? _a3 : {};
+    this.permissionMode = resolvePermissionMode({
+      permissionMode: settings.permissionMode
+    });
+    if (Object.keys(settings.harness.builtinTools).length > 0 && permissionModeNeedsBuiltinSupport({
+      permissionMode: this.permissionMode
+    }) && settings.harness.supportsBuiltinToolApprovals !== true) {
+      throw new HarnessCapabilityUnsupportedError({
+        message: `Harness '${settings.harness.harnessId}' does not support built-in tool approval requests; use permissionMode: 'allow-all'.`,
+        harnessId: settings.harness.harnessId
+      });
+    }
+    this.tools = {
+      ...settings.harness.builtinTools,
+      ...this.userTools
+    };
+  }
+  /** Identifier of the harness backing this agent. */
+  get harnessId() {
+    return this.settings.harness.harnessId;
+  }
+  /**
+   * Start a fresh session, or resume from state previously returned by
+   * `session.detach()` or `session.stop()`. The returned
+   * `HarnessAgentSession` must be passed to subsequent `generate` / `stream`
+   * calls; end it with `session.detach()`, `session.stop()`, or
+   * `session.destroy()`.
+   */
+  async createSession(options) {
+    var _a3;
+    const sessionId = (_a3 = options == null ? void 0 : options.sessionId) != null ? _a3 : generateId5();
+    const resumeFrom = options == null ? void 0 : options.resumeFrom;
+    const abortSignal = options == null ? void 0 : options.abortSignal;
+    const harness = this.settings.harness;
+    const sandboxProvider = this.settings.sandbox;
+    let validatedResumeFrom;
+    if (resumeFrom != null) {
+      validatedResumeFrom = await validateResumeStateData({
+        harness,
+        state: resumeFrom
+      });
+    }
+    let recipe;
+    let identity;
+    if (harness.getBootstrap != null) {
+      recipe = await harness.getBootstrap({ abortSignal });
+      identity = await hashBootstrap(recipe);
+    }
+    const acquiredSandboxSession = await this._acquireSandbox({
+      sandboxProvider,
+      sessionId,
+      isResume: validatedResumeFrom != null,
+      recipe,
+      identity,
+      abortSignal
+    });
+    const leased = applyPortLease({
+      provider: sandboxProvider,
+      sandboxSession: acquiredSandboxSession,
+      sessionId
+    });
+    const sandboxSession = leased.sandboxSession;
+    const leasedBridgePort = leased.port;
+    const sessionWorkDir = `${sandboxSession.defaultWorkingDirectory}/${harness.harnessId}-${sessionId}`;
+    try {
+      if (validatedResumeFrom == null && recipe != null && identity != null) {
+        await applyBootstrapRecipe(
+          sandboxSession.restricted(),
+          recipe,
+          identity,
+          { abortSignal }
+        );
+      }
+      await sandboxSession.run({
+        command: `mkdir -p ${sessionWorkDir}`,
+        abortSignal
+      });
+      if (this.settings.onSandboxSession != null) {
+        await this.settings.onSandboxSession({
+          session: sandboxSession.restricted(),
+          sessionWorkDir,
+          abortSignal
+        });
+      }
+    } catch (err) {
+      await cleanupAfterStartFailure({
+        sandboxProvider,
+        sandboxSession,
+        sessionId,
+        leasedBridgePort
+      });
+      throw err;
+    }
+    try {
+      const baseStartOptions = {
+        sessionId,
+        skills: this.settings.skills,
+        resumeFrom: validatedResumeFrom,
+        permissionMode: this.permissionMode,
+        abortSignal,
+        observability: buildObservability({ settings: this.settings })
+      };
+      const underlyingSession = await harness.doStart({
+        ...baseStartOptions,
+        sandboxSession,
+        sessionWorkDir
+      });
+      return new HarnessAgentSession({
+        sessionId,
+        harness,
+        underlyingSession,
+        sandboxSession,
+        sandboxProvider,
+        leasedBridgePort,
+        sessionWorkDir,
+        toolApproval: this.settings.toolApproval,
+        pendingToolApprovals: validatedResumeFrom == null ? void 0 : validatedResumeFrom.pendingToolApprovals
+      });
+    } catch (error) {
+      await cleanupAfterStartFailure({
+        sandboxProvider,
+        sandboxSession,
+        sessionId,
+        leasedBridgePort
+      });
+      throw error;
+    }
+  }
+  async generate(options) {
+    const turnInput = this._resolveTurnInput(options);
+    const runtimeContext = {};
+    const { result, done } = this._startTurn({
+      session: options.session,
+      turnInput,
+      runtimeContext,
+      abortSignal: options.abortSignal
+    });
+    await done;
+    return this._toGenerateResult(result);
+  }
+  async stream(options) {
+    const turnInput = this._resolveTurnInput(options);
+    const runtimeContext = {};
+    const { result } = this._startTurn({
+      session: options.session,
+      turnInput,
+      runtimeContext,
+      abortSignal: options.abortSignal
+    });
+    return result;
+  }
+  /**
+   * Continue the in-flight turn **without a new prompt**, streaming its events
+   * like {@link stream}. Used to keep consuming a turn that is still running
+   * (or finished) in the runtime after a process boundary — the workflow slice
+   * loop calls this on every slice after the first. Routes through the adapter's
+   * `doContinueTurn`; what it can guarantee (lossless attach vs. lossy rerun)
+   * follows from how the adapter resumed the session.
+   */
+  async continueTurn(options) {
+    const runtimeContext = {};
+    const { result } = options.session.continueTurn({
+      instructions: this.settings.instructions,
+      tools: this.tools,
+      toolSpecs: this._toToolSpecs(),
+      runtimeContext,
+      abortSignal: options.abortSignal,
+      telemetry: this.settings.telemetry,
+      toolApprovalContinuations: options.toolApprovalContinuations
+    });
+    return result;
+  }
+  // ─── Internals ──────────────────────────────────────────────────────
+  _startTurn(input) {
+    if (input.turnInput.mode === "continue") {
+      return input.session.continueTurn({
+        instructions: this.settings.instructions,
+        tools: this.tools,
+        toolSpecs: this._toToolSpecs(),
+        runtimeContext: input.runtimeContext,
+        abortSignal: input.abortSignal,
+        telemetry: this.settings.telemetry,
+        toolApprovalContinuations: input.turnInput.toolApprovalContinuations
+      });
+    }
+    return input.session.promptTurn({
+      prompt: input.turnInput.prompt,
+      instructions: this.settings.instructions,
+      tools: this.tools,
+      toolSpecs: this._toToolSpecs(),
+      runtimeContext: input.runtimeContext,
+      abortSignal: input.abortSignal,
+      telemetry: this.settings.telemetry
+    });
+  }
+  async _acquireSandbox(input) {
+    const { sandboxProvider } = input;
+    if (input.isResume) {
+      if (sandboxProvider.resumeSession == null) {
+        throw new HarnessCapabilityUnsupportedError({
+          message: `Sandbox provider '${sandboxProvider.providerId}' does not support resume.`,
+          harnessId: this.settings.harness.harnessId
+        });
+      }
+      return sandboxProvider.resumeSession({
+        sessionId: input.sessionId,
+        abortSignal: input.abortSignal
+      });
+    }
+    return sandboxProvider.createSession({
+      sessionId: input.sessionId,
+      abortSignal: input.abortSignal,
+      identity: input.identity,
+      onFirstCreate: input.recipe != null && input.identity != null ? (session, opts) => applyBootstrapRecipe(
+        session,
+        input.recipe,
+        input.identity,
+        opts
+      ) : void 0
+    });
+  }
+  /*
+   * Reduce AI SDK input to the single user message the harness should run
+   * for this turn. The harness session owns prior-turn state (system
+   * prompt, assistant turns, tool results) — we never replay it. A bare
+   * string is forwarded as-is; a message array is collapsed to its last
+   * `role: 'user'` entry. Inputs whose only messages are non-user (system,
+   * assistant, tool) have no fresh user input and are rejected.
+   */
+  _resolveTurnInput(options) {
+    if (typeof options.prompt === "string") {
+      return { mode: "prompt", prompt: options.prompt };
+    }
+    const messages = Array.isArray(options.prompt) ? options.prompt : options.messages;
+    if (Array.isArray(messages)) {
+      const toolApprovalContinuations = collectHarnessAgentToolApprovalContinuations({ messages });
+      if (toolApprovalContinuations.length > 0) {
+        return {
+          mode: "continue",
+          toolApprovalContinuations
+        };
+      }
+      for (let i = messages.length - 1; i >= 0; i--) {
+        const message = messages[i];
+        if ((message == null ? void 0 : message.role) === "user")
+          return { mode: "prompt", prompt: message };
+      }
+      throw new Error(
+        'HarnessAgent: messages must contain at least one `role: "user"` entry.'
+      );
+    }
+    throw new Error("HarnessAgent: either `prompt` or `messages` is required.");
+  }
+  /*
+   * Wire-format projection of user-defined tools only. Harness builtins are
+   * executed by the runtime and the bridge already knows about them — we
+   * never re-declare them over the wire.
+   */
+  _toToolSpecs() {
+    const specs = [];
+    for (const [name3, tool] of Object.entries(
+      this.userTools
+    )) {
+      const t = tool;
+      let inputSchema;
+      if (t.inputSchema != null) {
+        try {
+          inputSchema = asSchema(
+            t.inputSchema
+          ).jsonSchema;
+        } catch (e) {
+        }
+      }
+      specs.push({ name: name3, description: t.description, inputSchema });
+    }
+    return specs;
+  }
+  async _toGenerateResult(streamResult) {
+    const [steps, usage, responseMessages] = await Promise.all([
+      streamResult.steps,
+      streamResult.usage,
+      streamResult.responseMessages
+    ]);
+    return new HarnessGenerateTextResult({ steps, usage, responseMessages });
+  }
+};
+var HarnessGenerateTextResult = class {
+  constructor(options) {
+    this.output = void 0;
+    this.steps = options.steps;
+    this.usage = options.usage;
+    this.responseMessages = options.responseMessages;
+  }
+  get finalStep() {
+    return this.steps.at(-1);
+  }
+  get content() {
+    return this.steps.flatMap((step) => step.content);
+  }
+  get text() {
+    return this.finalStep.text;
+  }
+  get files() {
+    return this.steps.flatMap((step) => step.files);
+  }
+  get sources() {
+    return this.steps.flatMap((step) => step.sources);
+  }
+  get toolCalls() {
+    return this.steps.flatMap((step) => step.toolCalls);
+  }
+  get staticToolCalls() {
+    return this.steps.flatMap((step) => step.staticToolCalls);
+  }
+  get dynamicToolCalls() {
+    return this.steps.flatMap((step) => step.dynamicToolCalls);
+  }
+  get toolResults() {
+    return this.steps.flatMap((step) => step.toolResults);
+  }
+  get staticToolResults() {
+    return this.steps.flatMap((step) => step.staticToolResults);
+  }
+  get dynamicToolResults() {
+    return this.steps.flatMap((step) => step.dynamicToolResults);
+  }
+  get finishReason() {
+    return this.finalStep.finishReason;
+  }
+  get rawFinishReason() {
+    return this.finalStep.rawFinishReason;
+  }
+  get warnings() {
+    return this.steps.flatMap((step) => {
+      var _a3;
+      return (_a3 = step.warnings) != null ? _a3 : [];
+    });
+  }
+  get reasoning() {
+    return this.finalStep.content.filter(
+      (part) => part.type === "reasoning" || part.type === "reasoning-file"
+    );
+  }
+  get reasoningText() {
+    return this.finalStep.reasoningText;
+  }
+  get totalUsage() {
+    return this.usage;
+  }
+  get request() {
+    return this.finalStep.request;
+  }
+  get response() {
+    return this.finalStep.response;
+  }
+  get providerMetadata() {
+    return this.finalStep.providerMetadata;
+  }
+};
+function applyPortLease(input) {
+  const pool = input.provider.bridgePorts;
+  if (pool == null || pool.length === 0) {
+    return { sandboxSession: input.sandboxSession, port: void 0 };
+  }
+  const port = acquireBridgePort({
+    poolKey: input.provider,
+    pool,
+    sessionId: input.sessionId
+  });
+  return {
+    sandboxSession: narrowNetworkSessionPorts(input.sandboxSession, port),
+    port
+  };
+}
+function narrowNetworkSessionPorts(sandboxSession, leasedPort) {
+  return Object.create(sandboxSession, {
+    ports: {
+      value: [leasedPort],
+      enumerable: true
+    }
+  });
+}
+async function cleanupAfterStartFailure(input) {
+  await Promise.resolve(input.sandboxSession.stop()).catch(() => {
+  });
+  if (input.leasedBridgePort != null) {
+    releaseBridgePort({
+      poolKey: input.sandboxProvider,
+      sessionId: input.sessionId
+    });
+  }
+}
+
+// src/agent/prewarm.ts
+async function prewarmHarness(options) {
+  var _a3, _b3;
+  const recipe = await ((_b3 = (_a3 = options.harness).getBootstrap) == null ? void 0 : _b3.call(_a3, {
+    abortSignal: options.abortSignal
+  }));
+  if (recipe == null) return;
+  const identity = await hashBootstrap(recipe);
+  const sandboxSession = await options.sandboxProvider.createSession({
+    abortSignal: options.abortSignal,
+    identity,
+    onFirstCreate: (session, opts) => applyBootstrapRecipe(session, recipe, identity, opts)
+  });
+  try {
+    await applyBootstrapRecipe(sandboxSession.restricted(), recipe, identity, {
+      abortSignal: options.abortSignal
+    });
+  } finally {
+    await Promise.resolve(sandboxSession.stop()).catch(() => {
+    });
+  }
+}
+export {
+  HarnessAgent,
+  HarnessAgentSession,
+  collectHarnessAgentToolApprovalContinuations,
+  prewarmHarness
+};
+//# sourceMappingURL=index.js.map