@ai-sdk/harness 0.0.0-6b196531-20260710185421

package/dist/agent/index.js

@@ -0,0 +1,3491 @@
+// 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/lifecycle-state-validation.ts
+import { safeValidateTypes } from "@ai-sdk/provider-utils";
+async function validateLifecycleStateData(input) {
+  const { harness, state } = input;
+  if (state.type !== input.expectedType) {
+    throw new HarnessError({
+      message: `Lifecycle state has unexpected type '${state.type}'; expected '${input.expectedType}'.`
+    });
+  }
+  if (state.specificationVersion !== "harness-v1") {
+    throw new HarnessError({
+      message: `Lifecycle state has unexpected specificationVersion '${state.specificationVersion}'; expected 'harness-v1'.`
+    });
+  }
+  if (state.harnessId !== harness.harnessId) {
+    throw new HarnessError({
+      message: `Lifecycle state was produced by harness '${state.harnessId}' but this agent uses '${harness.harnessId}'.`
+    });
+  }
+  if (state.type === "resume-session" && "pendingToolApprovals" in state && state.pendingToolApprovals !== void 0) {
+    throw new HarnessError({
+      message: "Resume session state cannot contain pending tool approvals; unfinished turns must be stored as `continueFrom`."
+    });
+  }
+  const data = harness.lifecycleStateSchema == null ? state.data : await (async () => {
+    const result = await safeValidateTypes({
+      value: state.data,
+      schema: harness.lifecycleStateSchema
+    });
+    if (!result.success) {
+      throw new HarnessError({
+        message: `Lifecycle state failed schema validation for harness '${harness.harnessId}': ${result.error.message}`,
+        cause: result.error
+      });
+    }
+    return result.value;
+  })();
+  if (state.type === "resume-session") {
+    const continueFrom = state.continueFrom == null ? void 0 : await validateLifecycleStateData({
+      harness,
+      state: state.continueFrom,
+      expectedType: "continue-turn"
+    });
+    return {
+      type: state.type,
+      harnessId: state.harnessId,
+      specificationVersion: state.specificationVersion,
+      data,
+      ...continueFrom !== void 0 ? { continueFrom } : {}
+    };
+  }
+  return {
+    type: state.type,
+    harnessId: state.harnessId,
+    specificationVersion: state.specificationVersion,
+    data,
+    ...state.pendingToolApprovals !== void 0 ? { pendingToolApprovals: state.pendingToolApprovals } : {}
+  };
+}
+
+// src/v1/harness-v1-tool-filtering.ts
+function isHarnessV1BuiltinToolIncluded(input) {
+  if (input.toolFiltering == null) return true;
+  return input.toolFiltering.mode === "allow" ? input.toolFiltering.toolNames.includes(input.toolName) : !input.toolFiltering.toolNames.includes(input.toolName);
+}
+function getHarnessV1BuiltinToolFilteringDenialReason(input) {
+  return `Tool '${input.toolName}' is inactive due to the HarnessAgent tool filtering policy.`;
+}
+
+// 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(input) {
+    if (this.settled) return;
+    this.settled = true;
+    if (input != null) {
+      this.finalFinishReason = input.finishReason.unified;
+      this.finalRawFinishReason = input.finishReason.raw;
+      this.finalProviderMetadata = input.providerMetadata;
+      this.accumulatedUsage = asLanguageModelUsage(input.totalUsage);
+    }
+    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,
+          stepNumber,
+          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,
+            stepNumber,
+            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/utils/bridge-diagnostics.ts
+function isSerializedError(error) {
+  return typeof error === "object" && error != null && typeof error.message === "string";
+}
+function stringifyUnknown(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch (e) {
+    return String(value);
+  }
+}
+function formatBridgeError(error) {
+  var _a3, _b3;
+  if (error instanceof Error) {
+    return (_a3 = error.stack) != null ? _a3 : `${error.name}: ${error.message}`;
+  }
+  if (isSerializedError(error)) {
+    return (_b3 = error.stack) != null ? _b3 : `${error.name ? `${error.name}: ` : ""}${error.message}`;
+  }
+  return stringifyUnknown(error);
+}
+function writeToStderr(line) {
+  try {
+    process.stderr.write(line);
+  } catch (e) {
+  }
+}
+function logBridgeError({
+  harnessId,
+  sessionId,
+  context,
+  error,
+  write = writeToStderr
+}) {
+  const prefix = `[harness:${harnessId}:error${sessionId ? ` session=${sessionId}` : ""}]`;
+  const message = context ? `${context}: ${formatBridgeError(error)}` : formatBridgeError(error);
+  for (const line of message.split("\n")) {
+    if (line.trim().length > 0) {
+      write(`${prefix} ${line}
+`);
+    }
+  }
+}
+
+// src/agent/internal/run-prompt.ts
+function runPrompt(input) {
+  var _a3, _b3, _c, _d;
+  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 activeTools = (_d = input.activeTools) != null ? _d : input.tools;
+  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, _d2, _e, _f, _g, _h;
+    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);
+      logBridgeError({
+        harnessId: input.harness.harnessId,
+        sessionId: input.session.sessionId,
+        context: "failed to start harness turn",
+        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 finalFinish;
+    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: activeTools,
+        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;
+        }
+        if (displayValue.type === "tool-approval-request") {
+          const toolCall = toolCallsByToolCallId.get(displayValue.toolCallId);
+          if (toolCall == null) {
+            throw new Error(
+              `Harness '${input.harness.harnessId}' emitted approval request '${displayValue.approvalId}' for unknown tool call '${displayValue.toolCallId}'.`
+            );
+          }
+          const rawToolCall = rawToolCallsByToolCallId.get(
+            displayValue.toolCallId
+          );
+          const toolName = (_c2 = rawToolCall == null ? void 0 : rawToolCall.toolName) != null ? _c2 : toolCall.toolName;
+          if (!isHarnessV1BuiltinToolIncluded({
+            toolName,
+            toolFiltering: input.builtinToolFiltering
+          })) {
+            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: displayValue.approvalId,
+              approved: false,
+              reason: getHarnessV1BuiltinToolFilteringDenialReason({
+                toolName
+              })
+            });
+            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 = (_f = pendingApprovalsByApprovalId.get(value.approvalId)) != null ? _f : {
+            approvalId: value.approvalId,
+            toolCallId: value.toolCallId,
+            toolName: toolCall.toolName,
+            input: (_d2 = rawToolCall == null ? void 0 : rawToolCall.input) != null ? _d2 : JSON.stringify(toolCall.input),
+            kind: "builtin",
+            providerExecuted: (_e = rawToolCall == null ? void 0 : rawToolCall.providerExecuted) != null ? _e : 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") {
+          finalFinish = value;
+          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.`
+            );
+          }
+          if (!hasTool({ tools: activeTools, toolName: toolCall.toolName })) {
+            const output = {
+              type: "execution-denied",
+              reason: getHarnessV1BuiltinToolFilteringDenialReason({
+                toolName: toolCall.toolName
+              })
+            };
+            await control.submitToolResult({
+              toolCallId: toolCall.toolCallId,
+              output
+            });
+            telemetry.toolEnd(toolCall.toolCallId, { ok: true, output });
+            continue;
+          }
+          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 = (_g = pendingApprovalsByToolCallId.get(toolCall.toolCallId)) != null ? _g : 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: activeTools,
+            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);
+          logBridgeError({
+            harnessId: input.harness.harnessId,
+            sessionId: input.session.sessionId,
+            context: "harness stream error",
+            error: value.error
+          });
+          result.fail(value.error);
+          return;
+        }
+      }
+      (_h = input.onTurnFinished) == null ? void 0 : _h.call(input);
+      await result.finish(
+        finalFinish ? {
+          finishReason: finalFinish.finishReason,
+          totalUsage: finalFinish.totalUsage,
+          providerMetadata: finalFinish.harnessMetadata
+        } : void 0
+      );
+    } catch (err) {
+      telemetry.error(err);
+      logBridgeError({
+        harnessId: input.harness.harnessId,
+        sessionId: input.session.sessionId,
+        context: "harness turn failed",
+        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;
+}
+function hasTool(input) {
+  return Object.prototype.hasOwnProperty.call(input.tools, input.toolName);
+}
+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.sessionState = "active";
+    this.turnSequence = 0;
+    this.activeTurnSequence = 0;
+    var _a3, _b3;
+    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.turnState = (_b3 = options.turnState) != null ? _b3 : this.pendingToolApprovals.size > 0 ? "awaiting-approval" : "idle";
+    this.isResume = options.underlyingSession.isResume;
+  }
+  /**
+   * Active network sandbox session.
+   *
+   * @internal — accessed by session turn and lifecycle drivers.
+   */
+  getSandboxSession() {
+    if (this.sessionState !== "active" || 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();
+    this.requirePromptableTurn();
+    const sandboxSession = this.getSandboxSession();
+    const turnId = this.startTrackedTurn();
+    try {
+      const turn = runPrompt({
+        harness: this.harness,
+        session,
+        prompt: options.prompt,
+        instructions: options.instructions,
+        tools: options.tools,
+        activeTools: options.activeTools,
+        toolSpecs: options.toolSpecs,
+        builtinToolFiltering: options.builtinToolFiltering,
+        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);
+          this.markAwaitingApprovalIfActive();
+        },
+        onToolApprovalSettled: (approvalId) => {
+          this.pendingToolApprovals.delete(approvalId);
+        },
+        onTurnFinished: () => {
+          this.finishTrackedTurn({ turnId });
+        }
+      });
+      this.trackTurnCompletion({ done: turn.done, turnId });
+      return turn;
+    } catch (error) {
+      this.finishTrackedTurn({ turnId });
+      throw error;
+    }
+  }
+  continueTurn(options) {
+    const session = this.requireReusableSession();
+    this.requireContinuableTurn();
+    const sandboxSession = this.getSandboxSession();
+    const turnId = this.startTrackedTurn();
+    try {
+      const turn = runPrompt({
+        harness: this.harness,
+        session,
+        mode: "continue",
+        instructions: options.instructions,
+        tools: options.tools,
+        activeTools: options.activeTools,
+        toolSpecs: options.toolSpecs,
+        builtinToolFiltering: options.builtinToolFiltering,
+        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);
+          this.markAwaitingApprovalIfActive();
+        },
+        onToolApprovalSettled: (approvalId) => {
+          this.pendingToolApprovals.delete(approvalId);
+        },
+        onTurnFinished: () => {
+          this.finishTrackedTurn({ turnId });
+        }
+      });
+      this.trackTurnCompletion({ done: turn.done, turnId });
+      return turn;
+    } catch (error) {
+      this.finishTrackedTurn({ turnId });
+      throw error;
+    }
+  }
+  /**
+   * 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.sessionState !== "active" || this.underlyingSession == null) {
+      throw new Error(
+        `Harness session ${this.sessionId} is not active and cannot be detached.`
+      );
+    }
+    const session = this.underlyingSession;
+    try {
+      if (this.turnState !== "idle") {
+        return this.toResumeStateWithContinuation({
+          continueFrom: await this.suspendCurrentTurn({ session })
+        });
+      }
+      const raw = await session.doDetach();
+      const validated = await validateLifecycleStateData({
+        harness: this.harness,
+        state: raw,
+        expectedType: "resume-session"
+      });
+      return validated;
+    } finally {
+      this.endLocalHandle({
+        sessionState: "detached",
+        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.sessionState !== "active" || 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 {
+      if (this.turnState !== "idle") {
+        return this.toResumeStateWithContinuation({
+          continueFrom: await this.suspendCurrentTurn({ session })
+        });
+      }
+      const raw = await session.doStop();
+      const validated = await validateLifecycleStateData({
+        harness: this.harness,
+        state: raw,
+        expectedType: "resume-session"
+      });
+      return validated;
+    } finally {
+      this.endLocalHandle({
+        sessionState: "stopped",
+        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.sessionState !== "active") return;
+    const session = this.underlyingSession;
+    const sandboxSession = this.getSandboxSession();
+    this.endLocalHandle({ sessionState: "destroyed", 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
+   * continuation payload, **leaving the sandbox/runtime running** so the next
+   * process can continue. Resolves once the in-flight `stream()` /
+   * `continueStream()` has cleanly wound down at a precise cursor (see
+   * `doSuspendTurn`).
+   *
+   * After this call the session is detached. 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.sessionState !== "active" || this.underlyingSession == null) {
+      throw new Error(
+        `Harness session ${this.sessionId} is not active and cannot be suspended.`
+      );
+    }
+    if (this.turnState === "idle") {
+      throw new Error(
+        `Harness session ${this.sessionId} has no unfinished turn to suspend.`
+      );
+    }
+    const session = this.underlyingSession;
+    try {
+      return await this.suspendCurrentTurn({ session });
+    } finally {
+      this.endLocalHandle({
+        sessionState: "detached",
+        releasePortLease: false
+      });
+    }
+  }
+  getPendingToolApprovals() {
+    return Array.from(this.pendingToolApprovals.values());
+  }
+  addPendingToolApprovals(state) {
+    const pendingToolApprovals = this.getPendingToolApprovals();
+    if (pendingToolApprovals.length === 0) {
+      return {
+        type: state.type,
+        harnessId: state.harnessId,
+        specificationVersion: state.specificationVersion,
+        data: state.data
+      };
+    }
+    return {
+      ...state,
+      pendingToolApprovals
+    };
+  }
+  async suspendCurrentTurn(options) {
+    const raw = await options.session.doSuspendTurn();
+    const validated = await validateLifecycleStateData({
+      harness: this.harness,
+      state: raw,
+      expectedType: "continue-turn"
+    });
+    this.turnState = "suspended";
+    return this.addPendingToolApprovals(validated);
+  }
+  toResumeStateWithContinuation(options) {
+    const { continueFrom } = options;
+    return {
+      type: "resume-session",
+      harnessId: continueFrom.harnessId,
+      specificationVersion: continueFrom.specificationVersion,
+      data: continueFrom.data,
+      continueFrom
+    };
+  }
+  requirePromptableTurn() {
+    if (this.turnState === "idle") return;
+    if (this.turnState === "running") {
+      throw new Error(
+        `Harness session ${this.sessionId} already has a turn in progress.`
+      );
+    }
+    throw new Error(
+      `Harness session ${this.sessionId} has an unfinished turn and must be continued before accepting a new prompt.`
+    );
+  }
+  requireContinuableTurn() {
+    if (this.turnState === "awaiting-approval" || this.turnState === "suspended") {
+      return;
+    }
+    if (this.turnState === "running") {
+      throw new Error(
+        `Harness session ${this.sessionId} already has a turn in progress.`
+      );
+    }
+    throw new Error(
+      `Harness session ${this.sessionId} has no unfinished turn to continue.`
+    );
+  }
+  markAwaitingApprovalIfActive() {
+    if (this.sessionState === "active") {
+      this.turnState = "awaiting-approval";
+    }
+  }
+  startTrackedTurn() {
+    const turnId = ++this.turnSequence;
+    this.activeTurnSequence = turnId;
+    this.turnState = "running";
+    return turnId;
+  }
+  trackTurnCompletion(options) {
+    void Promise.resolve(options.done).finally(() => {
+      this.finishTrackedTurn({ turnId: options.turnId });
+    }).catch(() => {
+    });
+  }
+  finishTrackedTurn(options) {
+    if (this.sessionState !== "active") return;
+    if (this.activeTurnSequence !== options.turnId) return;
+    this.turnState = this.pendingToolApprovals.size > 0 ? "awaiting-approval" : "idle";
+  }
+  endLocalHandle(options) {
+    this.sessionState = options.sessionState;
+    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.sessionState !== "active" || 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 hashHarnessBootstrap(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/sandbox-bootstrap.ts
+import { posix } from "path";
+var SANDBOX_BOOTSTRAP_IDENTITY_VERSION = 1;
+function validateSandboxBootstrapSettings(settings) {
+  if (settings.onBootstrap == null !== (settings.bootstrapHash == null)) {
+    throw new Error(
+      "HarnessAgent: `sandboxConfig.onBootstrap` and `sandboxConfig.bootstrapHash` must be provided together."
+    );
+  }
+  if (settings.workDir != null) {
+    normalizeSandboxWorkDir(settings.workDir);
+  }
+}
+function normalizeSandboxWorkDir(workDir) {
+  if (workDir.length === 0) {
+    throw new Error("HarnessAgent: `sandboxConfig.workDir` must not be empty.");
+  }
+  if (workDir.includes("\0")) {
+    throw new Error(
+      "HarnessAgent: `sandboxConfig.workDir` must not contain NUL."
+    );
+  }
+  if (workDir.includes("\\")) {
+    throw new Error(
+      "HarnessAgent: `sandboxConfig.workDir` must use POSIX path separators."
+    );
+  }
+  if (posix.isAbsolute(workDir)) {
+    throw new Error("HarnessAgent: `sandboxConfig.workDir` must be relative.");
+  }
+  const normalized = posix.normalize(workDir);
+  if (normalized === "." || normalized === ".." || normalized.startsWith("../")) {
+    throw new Error(
+      "HarnessAgent: `sandboxConfig.workDir` must stay inside the sandbox default working directory."
+    );
+  }
+  return normalized;
+}
+function resolveSessionWorkDir({
+  defaultWorkingDirectory,
+  harnessId,
+  sessionId,
+  workDir
+}) {
+  return joinSandboxPath({
+    base: defaultWorkingDirectory,
+    path: workDir != null ? workDir : `${harnessId}-${sessionId}`
+  });
+}
+async function createSandboxBootstrapPlan({
+  recipe,
+  settings
+}) {
+  const workDir = settings.workDir == null ? void 0 : normalizeSandboxWorkDir(settings.workDir);
+  const recipeIdentity = recipe == null ? void 0 : await hashHarnessBootstrap(recipe);
+  const hasCallerBootstrap = settings.onBootstrap != null;
+  const needsCombinedIdentity = hasCallerBootstrap || recipeIdentity != null && workDir != null;
+  const identity = needsCombinedIdentity && (recipeIdentity != null || hasCallerBootstrap) ? await hashSandboxBootstrapIdentity({
+    recipeIdentity,
+    bootstrapHash: settings.bootstrapHash,
+    workDir
+  }) : recipeIdentity;
+  return {
+    ...recipe != null ? { recipe } : {},
+    ...recipeIdentity != null ? { recipeIdentity } : {},
+    ...identity != null ? { identity } : {},
+    ...workDir != null ? { workDir } : {},
+    ...recipe != null || settings.onBootstrap != null ? {
+      onFirstCreate: (session, opts) => runSandboxBootstrap({
+        session,
+        recipe,
+        recipeIdentity,
+        workDir,
+        onBootstrap: settings.onBootstrap,
+        abortSignal: opts.abortSignal
+      })
+    } : {}
+  };
+}
+async function runSandboxBootstrap({
+  session,
+  recipe,
+  recipeIdentity,
+  workDir,
+  onBootstrap,
+  abortSignal
+}) {
+  if (recipe != null && recipeIdentity != null) {
+    await applyBootstrapRecipe(session, recipe, recipeIdentity, {
+      abortSignal
+    });
+  }
+  if (onBootstrap == null) return;
+  const defaultWorkingDirectory = await resolveDefaultWorkingDirectory({
+    session,
+    abortSignal
+  });
+  const bootstrapWorkDir = workDir == null ? defaultWorkingDirectory : joinSandboxPath({
+    base: defaultWorkingDirectory,
+    path: workDir
+  });
+  await ensureSandboxDirectory({
+    session,
+    workDir: bootstrapWorkDir,
+    abortSignal
+  });
+  await onBootstrap({ session, workDir: bootstrapWorkDir, abortSignal });
+}
+async function resolveDefaultWorkingDirectory({
+  session,
+  abortSignal
+}) {
+  const result = await session.run({
+    command: "pwd",
+    abortSignal
+  });
+  if (result.exitCode !== 0) {
+    throw new Error(
+      `Failed to resolve sandbox default working directory (exit ${result.exitCode}): ${result.stderr || result.stdout}`
+    );
+  }
+  const cwd = result.stdout.trim();
+  if (!posix.isAbsolute(cwd)) {
+    throw new Error(
+      `Failed to resolve sandbox default working directory: expected an absolute path, got ${JSON.stringify(cwd)}.`
+    );
+  }
+  return cwd === "/" ? cwd : cwd.replace(/\/+$/, "");
+}
+async function ensureSandboxDirectory({
+  session,
+  workDir,
+  abortSignal
+}) {
+  const result = await session.run({
+    command: 'mkdir -p "$WORK_DIR"',
+    env: { WORK_DIR: workDir },
+    abortSignal
+  });
+  if (result.exitCode !== 0) {
+    throw new Error(
+      `Failed to create sandbox work directory ${workDir} (exit ${result.exitCode}): ${result.stderr || result.stdout}`
+    );
+  }
+}
+async function hashSandboxBootstrapIdentity({
+  recipeIdentity,
+  bootstrapHash,
+  workDir
+}) {
+  const encoder = new TextEncoder();
+  const chunks = [];
+  const pushString = (value) => {
+    chunks.push(encoder.encode(value));
+    chunks.push(encoder.encode("\0"));
+  };
+  pushString(String(SANDBOX_BOOTSTRAP_IDENTITY_VERSION));
+  pushString(recipeIdentity != null ? recipeIdentity : "");
+  pushString(bootstrapHash != null ? bootstrapHash : "");
+  pushString(workDir != null ? workDir : "");
+  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 joinSandboxPath({
+  base,
+  path
+}) {
+  return posix.join(base, path);
+}
+
+// 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/internal/tool-filtering.ts
+import { NoSuchToolError } from "ai";
+function resolveHarnessAgentToolFiltering(input) {
+  if (input.activeTools !== void 0 && input.inactiveTools !== void 0) {
+    throw new Error(
+      "HarnessAgent: pass either `activeTools` or `inactiveTools`, not both."
+    );
+  }
+  const allToolNames = Object.keys(input.allTools);
+  const activeTools = dedupeToolNames({ toolNames: input.activeTools });
+  const inactiveTools = dedupeToolNames({ toolNames: input.inactiveTools });
+  validateToolNames({
+    requestedToolNames: activeTools != null ? activeTools : inactiveTools,
+    availableToolNames: allToolNames
+  });
+  const userToolNames = Object.keys(input.userTools);
+  const activeUserToolNames = activeTools != null ? userToolNames.filter((name3) => activeTools.includes(name3)) : inactiveTools != null ? userToolNames.filter((name3) => !inactiveTools.includes(name3)) : userToolNames;
+  const builtinToolNames = Object.keys(input.harness.builtinTools);
+  const disabledBuiltinToolNames = activeTools != null ? builtinToolNames.filter((name3) => !activeTools.includes(name3)) : inactiveTools != null ? builtinToolNames.filter((name3) => inactiveTools.includes(name3)) : [];
+  const builtinToolFiltering = disabledBuiltinToolNames.length > 0 ? activeTools != null ? {
+    mode: "allow",
+    toolNames: builtinToolNames.filter(
+      (name3) => activeTools.includes(name3)
+    )
+  } : { mode: "deny", toolNames: disabledBuiltinToolNames } : void 0;
+  if (builtinToolFiltering != null && input.harness.supportsBuiltinToolFiltering !== true && input.harness.supportsBuiltinToolApprovals !== true) {
+    throw new HarnessCapabilityUnsupportedError({
+      message: `Harness '${input.harness.harnessId}' does not support built-in tool filtering controls.`,
+      harnessId: input.harness.harnessId
+    });
+  }
+  return {
+    activeUserTools: filterToolSet({
+      tools: input.userTools,
+      toolNames: activeUserToolNames
+    }),
+    ...builtinToolFiltering != null ? { builtinToolFiltering } : {}
+  };
+}
+function dedupeToolNames(input) {
+  return input.toolNames == null ? void 0 : Array.from(new Set(input.toolNames));
+}
+function validateToolNames(input) {
+  if (input.requestedToolNames == null) return;
+  for (const toolName of input.requestedToolNames) {
+    if (!input.availableToolNames.includes(toolName)) {
+      throw new NoSuchToolError({
+        toolName,
+        availableTools: [...input.availableToolNames]
+      });
+    }
+  }
+}
+function filterToolSet(input) {
+  const allowed = new Set(input.toolNames);
+  return Object.fromEntries(
+    Object.entries(input.tools).filter(([name3]) => allowed.has(name3))
+  );
+}
+
+// src/agent/harness-agent.ts
+var HarnessAgent = class {
+  constructor(settings) {
+    this.version = "agent-v1";
+    var _a3;
+    const sandboxConfig = resolveSandboxConfig(settings);
+    validateSandboxBootstrapSettings(sandboxConfig);
+    this.settings = settings;
+    this.sandboxConfig = sandboxConfig;
+    this.id = settings.id;
+    const userTools = (_a3 = settings.tools) != null ? _a3 : {};
+    this.permissionMode = resolvePermissionMode({
+      permissionMode: settings.permissionMode
+    });
+    const tools = {
+      ...settings.harness.builtinTools,
+      ...userTools
+    };
+    const toolFiltering = resolveHarnessAgentToolFiltering({
+      harness: settings.harness,
+      userTools,
+      allTools: tools,
+      activeTools: settings.activeTools,
+      inactiveTools: settings.inactiveTools
+    });
+    this.activeUserTools = toolFiltering.activeUserTools;
+    this.builtinToolFiltering = toolFiltering.builtinToolFiltering;
+    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 = tools;
+  }
+  /** 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 continueFrom = options == null ? void 0 : options.continueFrom;
+    const abortSignal = options == null ? void 0 : options.abortSignal;
+    const harness = this.settings.harness;
+    const sandboxProvider = this.settings.sandbox;
+    if (resumeFrom != null && continueFrom != null) {
+      throw new Error(
+        "HarnessAgent.createSession: pass either `resumeFrom` or `continueFrom`, not both."
+      );
+    }
+    let validatedResumeFrom;
+    if (resumeFrom != null) {
+      validatedResumeFrom = await validateLifecycleStateData({
+        harness,
+        state: resumeFrom,
+        expectedType: "resume-session"
+      });
+    }
+    let validatedContinueFrom;
+    if (continueFrom != null) {
+      validatedContinueFrom = await validateLifecycleStateData({
+        harness,
+        state: continueFrom,
+        expectedType: "continue-turn"
+      });
+    }
+    const effectiveContinueFrom = validatedContinueFrom != null ? validatedContinueFrom : validatedResumeFrom == null ? void 0 : validatedResumeFrom.continueFrom;
+    const isResumedSession = validatedResumeFrom != null || effectiveContinueFrom != null;
+    let recipe;
+    if (harness.getBootstrap != null) {
+      recipe = await harness.getBootstrap({ abortSignal });
+    }
+    const sandboxBootstrapPlan = await createSandboxBootstrapPlan({
+      recipe,
+      settings: this.sandboxConfig
+    });
+    const acquiredSandboxSession = await this._acquireSandbox({
+      sandboxProvider,
+      sessionId,
+      isResume: isResumedSession,
+      bootstrapPlan: sandboxBootstrapPlan,
+      abortSignal
+    });
+    const leased = applyPortLease({
+      provider: sandboxProvider,
+      sandboxSession: acquiredSandboxSession,
+      sessionId
+    });
+    const sandboxSession = leased.sandboxSession;
+    const leasedBridgePort = leased.port;
+    const sessionWorkDir = resolveSessionWorkDir({
+      defaultWorkingDirectory: sandboxSession.defaultWorkingDirectory,
+      harnessId: harness.harnessId,
+      sessionId,
+      workDir: sandboxBootstrapPlan.workDir
+    });
+    try {
+      if (!isResumedSession && sandboxBootstrapPlan.recipe != null && sandboxBootstrapPlan.recipeIdentity != null) {
+        await applyBootstrapRecipe(
+          sandboxSession.restricted(),
+          sandboxBootstrapPlan.recipe,
+          sandboxBootstrapPlan.recipeIdentity,
+          { abortSignal }
+        );
+      }
+      await ensureSandboxDirectory({
+        session: sandboxSession,
+        workDir: sessionWorkDir,
+        abortSignal
+      });
+      if (this.sandboxConfig.onSession != null) {
+        await this.sandboxConfig.onSession({
+          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,
+        continueFrom: effectiveContinueFrom,
+        permissionMode: this.permissionMode,
+        builtinToolFiltering: this.builtinToolFiltering,
+        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: effectiveContinueFrom == null ? void 0 : effectiveContinueFrom.pendingToolApprovals,
+        turnState: effectiveContinueFrom == null ? "idle" : effectiveContinueFrom.pendingToolApprovals != null && effectiveContinueFrom.pendingToolApprovals.length > 0 ? "awaiting-approval" : "suspended"
+      });
+    } 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**, draining it like
+   * {@link generate}. Used after `createSession({ continueFrom })` to finish
+   * consuming a turn that crossed a process boundary.
+   */
+  async continueGenerate(options) {
+    var _a3;
+    const runtimeContext = {};
+    const { result, done } = this._startTurn({
+      session: options.session,
+      turnInput: {
+        mode: "continue",
+        toolApprovalContinuations: (_a3 = options.toolApprovalContinuations) != null ? _a3 : []
+      },
+      runtimeContext,
+      abortSignal: options.abortSignal
+    });
+    await done;
+    return this._toGenerateResult(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 continueStream(options) {
+    var _a3;
+    const runtimeContext = {};
+    const { result } = this._startTurn({
+      session: options.session,
+      turnInput: {
+        mode: "continue",
+        toolApprovalContinuations: (_a3 = options.toolApprovalContinuations) != null ? _a3 : []
+      },
+      runtimeContext,
+      abortSignal: options.abortSignal
+    });
+    return result;
+  }
+  // ─── Internals ──────────────────────────────────────────────────────
+  _startTurn(input) {
+    if (input.turnInput.mode === "continue") {
+      return input.session.continueTurn({
+        instructions: this.settings.instructions,
+        tools: this.tools,
+        activeTools: this.activeUserTools,
+        toolSpecs: this._toToolSpecs(),
+        builtinToolFiltering: this.builtinToolFiltering,
+        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,
+      activeTools: this.activeUserTools,
+      toolSpecs: this._toToolSpecs(),
+      builtinToolFiltering: this.builtinToolFiltering,
+      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.bootstrapPlan.identity,
+      onFirstCreate: input.bootstrapPlan.onFirstCreate
+    });
+  }
+  /*
+   * 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.activeUserTools
+    )) {
+      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 resolveSandboxConfig(settings) {
+  var _a3;
+  if (settings.onSandboxSession != null) {
+    console.warn(
+      "HarnessAgent: `onSandboxSession` is deprecated. Use `sandboxConfig.onSession` instead."
+    );
+  }
+  return {
+    ...settings.sandboxConfig,
+    ...((_a3 = settings.sandboxConfig) == null ? void 0 : _a3.onSession) == null && settings.onSandboxSession != null ? { onSession: settings.onSandboxSession } : {}
+  };
+}
+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/prepare-harness-sandbox-template.ts
+async function prepareHarnessSandboxTemplate(options) {
+  var _a3, _b3, _c;
+  const sandboxConfig = (_a3 = options.sandboxConfig) != null ? _a3 : {};
+  validateSandboxBootstrapSettings(sandboxConfig);
+  const recipe = await ((_c = (_b3 = options.harness).getBootstrap) == null ? void 0 : _c.call(_b3, {
+    abortSignal: options.abortSignal
+  }));
+  const bootstrapPlan = await createSandboxBootstrapPlan({
+    recipe,
+    settings: sandboxConfig
+  });
+  if (bootstrapPlan.identity == null || bootstrapPlan.onFirstCreate == null) {
+    return;
+  }
+  const sandboxSession = await options.sandboxProvider.createSession({
+    abortSignal: options.abortSignal,
+    identity: bootstrapPlan.identity,
+    onFirstCreate: bootstrapPlan.onFirstCreate
+  });
+  try {
+    if (bootstrapPlan.recipe != null && bootstrapPlan.recipeIdentity != null) {
+      await applyBootstrapRecipe(
+        sandboxSession.restricted(),
+        bootstrapPlan.recipe,
+        bootstrapPlan.recipeIdentity,
+        {
+          abortSignal: options.abortSignal
+        }
+      );
+    }
+  } finally {
+    await Promise.resolve(sandboxSession.stop()).catch(() => {
+    });
+  }
+}
+var prewarmHarness = prepareHarnessSandboxTemplate;
+
+// src/agent/prepare-sandbox-for-harness.ts
+var PREPARED_SANDBOX_IDENTITY_VERSION = 1;
+async function prepareSandboxForHarness(options) {
+  var _a3, _b3;
+  const sandboxConfig = (_a3 = options.sandboxConfig) != null ? _a3 : {};
+  validateSandboxBootstrapSettings(sandboxConfig);
+  if (options.harnesses.length === 0) {
+    throw new Error(
+      "prepareSandboxForHarness: at least one harness must be provided."
+    );
+  }
+  const harnesses = [...options.harnesses].sort(
+    (a, b) => a.harnessId.localeCompare(b.harnessId)
+  );
+  assertUniqueHarnessIds(harnesses);
+  const workDir = sandboxConfig.workDir == null ? void 0 : normalizeSandboxWorkDir(sandboxConfig.workDir);
+  const recipeIdentities = {};
+  const skippedHarnessIds = [];
+  for (const harness of harnesses) {
+    const recipe = await ((_b3 = harness.getBootstrap) == null ? void 0 : _b3.call(harness, {
+      abortSignal: options.abortSignal
+    }));
+    if (recipe == null) {
+      skippedHarnessIds.push(harness.harnessId);
+      continue;
+    }
+    const recipeIdentity = await hashHarnessBootstrap(recipe);
+    recipeIdentities[harness.harnessId] = recipeIdentity;
+    await applyBootstrapRecipe(options.session, recipe, recipeIdentity, {
+      abortSignal: options.abortSignal
+    });
+  }
+  if (sandboxConfig.onBootstrap != null) {
+    await runSandboxBootstrap({
+      session: options.session,
+      workDir,
+      onBootstrap: sandboxConfig.onBootstrap,
+      abortSignal: options.abortSignal
+    });
+  }
+  const identity = await resolvePreparedSandboxIdentity({
+    recipeIdentities,
+    bootstrapHash: sandboxConfig.bootstrapHash,
+    workDir
+  });
+  return {
+    ...identity != null ? { identity } : {},
+    recipeIdentities,
+    skippedHarnessIds
+  };
+}
+function assertUniqueHarnessIds(harnesses) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const harness of harnesses) {
+    if (seen.has(harness.harnessId)) {
+      throw new Error(
+        `prepareSandboxForHarness: duplicate harness id "${harness.harnessId}".`
+      );
+    }
+    seen.add(harness.harnessId);
+  }
+}
+async function resolvePreparedSandboxIdentity({
+  recipeIdentities,
+  bootstrapHash,
+  workDir
+}) {
+  const entries = Object.entries(recipeIdentities).sort(
+    ([a], [b]) => a.localeCompare(b)
+  );
+  if (entries.length === 0 && bootstrapHash == null) {
+    return void 0;
+  }
+  const encoder = new TextEncoder();
+  const chunks = [];
+  const pushString = (value) => {
+    chunks.push(encoder.encode(value));
+    chunks.push(encoder.encode("\0"));
+  };
+  pushString(String(PREPARED_SANDBOX_IDENTITY_VERSION));
+  pushString(workDir != null ? workDir : "");
+  pushString(bootstrapHash != null ? bootstrapHash : "");
+  for (const [harnessId, identity] of entries) {
+    pushString(harnessId);
+    pushString(identity);
+  }
+  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;
+}
+
+// src/agent/observability/file-reporter.ts
+import { appendFileSync, mkdirSync } from "fs";
+function createFileReporter(options) {
+  var _a3, _b3;
+  const fileName = (_a3 = options.fileName) != null ? _a3 : "events.jsonl";
+  const path = `${options.dir}/${fileName}`;
+  const failOnly = (_b3 = options.failOnly) != null ? _b3 : false;
+  const turns = /* @__PURE__ */ new Map();
+  let lastOpenCallId;
+  let dirReady = false;
+  const bucketFor = (callId) => {
+    let bucket = turns.get(callId);
+    if (!bucket) {
+      bucket = { lines: [], errored: false };
+      turns.set(callId, bucket);
+    }
+    return bucket;
+  };
+  const record = (callId, rec) => {
+    const id = callId != null ? callId : lastOpenCallId;
+    if (id == null) {
+      flushLines([rec]);
+      return;
+    }
+    bucketFor(id).lines.push(rec);
+  };
+  const flushLines = (lines) => {
+    if (lines.length === 0) return;
+    try {
+      if (!dirReady) {
+        mkdirSync(options.dir, { recursive: true });
+        dirReady = true;
+      }
+      appendFileSync(path, lines.map((l) => JSON.stringify(l)).join("\n") + "\n");
+    } catch (e) {
+    }
+  };
+  const finishTurn = (callId) => {
+    const bucket = turns.get(callId);
+    if (!bucket) return;
+    turns.delete(callId);
+    if (lastOpenCallId === callId) lastOpenCallId = void 0;
+    if (failOnly && !bucket.errored) return;
+    flushLines(bucket.lines);
+  };
+  return {
+    onStart(event) {
+      const e = event;
+      lastOpenCallId = e.callId;
+      record(e.callId, {
+        ts: Date.now(),
+        kind: "turn-start",
+        callId: e.callId,
+        operationId: e.operationId,
+        provider: e.provider,
+        modelId: e.modelId,
+        // Input prompt, unless the consumer opted out via `recordInputs: false`.
+        ...e.recordInputs === false ? {} : { input: { messages: e.messages, instructions: e.instructions } }
+      });
+    },
+    onStepStart(event) {
+      const e = event;
+      record(e.callId, {
+        ts: Date.now(),
+        kind: "step-start",
+        callId: e.callId,
+        step: e.stepNumber
+      });
+    },
+    onToolExecutionStart(event) {
+      const e = event;
+      record(e.callId, {
+        ts: Date.now(),
+        kind: "tool-start",
+        callId: e.callId,
+        toolName: e.toolCall.toolName,
+        toolCallId: e.toolCall.toolCallId,
+        input: e.toolCall.input
+      });
+    },
+    onToolExecutionEnd(event) {
+      const e = event;
+      const isError = e.toolOutput.type === "error";
+      if (isError) bucketFor(e.callId).errored = true;
+      record(e.callId, {
+        ts: Date.now(),
+        kind: "tool-end",
+        callId: e.callId,
+        toolCallId: e.toolCall.toolCallId,
+        isError,
+        output: isError ? e.toolOutput.error : e.toolOutput.output
+      });
+    },
+    onStepFinish(event) {
+      const e = event;
+      record(e.callId, {
+        ts: Date.now(),
+        kind: "step-finish",
+        callId: e.callId,
+        usage: e.usage,
+        // The model's output content, unless `recordOutputs: false`.
+        ...e.recordOutputs === false || e.content == null ? {} : { output: e.content }
+      });
+    },
+    onEnd(event) {
+      var _a4;
+      const e = event;
+      record(e.callId, {
+        ts: Date.now(),
+        kind: "turn-finish",
+        callId: e.callId,
+        finishReason: e.finishReason,
+        usage: (_a4 = e.totalUsage) != null ? _a4 : e.usage
+      });
+      finishTurn(e.callId);
+    },
+    onError(error) {
+      if (lastOpenCallId != null) bucketFor(lastOpenCallId).errored = true;
+      record(lastOpenCallId, {
+        ts: Date.now(),
+        kind: "error",
+        error: error instanceof Error ? { name: error.name, message: error.message } : error
+      });
+    },
+    ingestDiagnostic(diagnostic) {
+      if (diagnostic.level === "error" && lastOpenCallId != null) {
+        bucketFor(lastOpenCallId).errored = true;
+      }
+      record(lastOpenCallId, {
+        ts: diagnostic.timestamp,
+        kind: "diagnostic",
+        diagnostic
+      });
+    }
+  };
+}
+
+// src/agent/observability/trace-tree-reporter.ts
+function createTraceTreeReporter(options = {}) {
+  var _a3;
+  const write = (_a3 = options.write) != null ? _a3 : ((chunk) => void process.stderr.write(chunk));
+  const turns = /* @__PURE__ */ new Map();
+  const render = (node, depth) => {
+    const indent = "  ".repeat(depth);
+    const dur = node.endMs != null ? `${Math.max(0, Math.round(node.endMs - node.startMs))}ms` : "(open)";
+    let out = `${indent}- ${node.label} ${dur}
+`;
+    for (const child of node.children) out += render(child, depth + 1);
+    return out;
+  };
+  return {
+    onStart(event) {
+      var _a4;
+      const e = event;
+      turns.set(e.callId, {
+        root: {
+          label: `${(_a4 = e.operationId) != null ? _a4 : "turn"}${e.modelId ? ` ${e.modelId}` : ""}`,
+          startMs: Date.now(),
+          children: []
+        },
+        tools: /* @__PURE__ */ new Map()
+      });
+    },
+    onStepStart(event) {
+      var _a4;
+      const e = event;
+      const turn = turns.get(e.callId);
+      if (!turn) return;
+      const step = {
+        label: `step ${((_a4 = e.stepNumber) != null ? _a4 : turn.root.children.length) + 1}`,
+        startMs: Date.now(),
+        children: []
+      };
+      turn.step = step;
+      turn.root.children.push(step);
+    },
+    onToolExecutionStart(event) {
+      var _a4;
+      const e = event;
+      const turn = turns.get(e.callId);
+      const parent = (_a4 = turn == null ? void 0 : turn.step) != null ? _a4 : turn == null ? void 0 : turn.root;
+      if (!turn || !parent) return;
+      const node = {
+        label: `tool ${e.toolCall.toolName}`,
+        startMs: Date.now(),
+        children: []
+      };
+      turn.tools.set(e.toolCall.toolCallId, node);
+      parent.children.push(node);
+    },
+    onToolExecutionEnd(event) {
+      var _a4;
+      const e = event;
+      const node = (_a4 = turns.get(e.callId)) == null ? void 0 : _a4.tools.get(e.toolCall.toolCallId);
+      if (!node) return;
+      node.endMs = Date.now();
+      if (e.toolOutput.type === "error") node.label += " [error]";
+    },
+    onStepFinish(event) {
+      const e = event;
+      const turn = turns.get(e.callId);
+      if (turn == null ? void 0 : turn.step) {
+        turn.step.endMs = Date.now();
+        turn.step = void 0;
+      }
+    },
+    onEnd(event) {
+      const e = event;
+      const turn = turns.get(e.callId);
+      if (!turn) return;
+      turn.root.endMs = Date.now();
+      turns.delete(e.callId);
+      try {
+        write(`
+${render(turn.root, 0)}`);
+      } catch (e2) {
+      }
+    }
+  };
+}
+export {
+  HarnessAgent,
+  HarnessAgentSession,
+  HarnessCapabilityUnsupportedError,
+  HarnessError,
+  collectHarnessAgentToolApprovalContinuations,
+  createFileReporter,
+  createTraceTreeReporter,
+  prepareHarnessSandboxTemplate,
+  prepareSandboxForHarness,
+  prewarmHarness
+};
+//# sourceMappingURL=index.js.map