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

package/dist/utils/index.js

@@ -0,0 +1,1241 @@
+// src/utils/sandbox-channel.ts
+import {
+  safeParseJSON,
+  safeValidateTypes
+} from "@ai-sdk/provider-utils";
+var sleep = (ms) => new Promise((resolve) => {
+  var _a;
+  const t = setTimeout(resolve, ms);
+  (_a = t.unref) == null ? void 0 : _a.call(t);
+});
+var SandboxChannel = class {
+  constructor(options) {
+    this.listeners = /* @__PURE__ */ new Map();
+    this.buffered = /* @__PURE__ */ new Map();
+    this.onCloseHandlers = /* @__PURE__ */ new Set();
+    this.connected = false;
+    /** Host has begun teardown; suppresses reconnect so a bridge-side close finalises. */
+    this.closing = false;
+    /**
+     * Host has gracefully suspended (slice boundary). Inbound frames are ignored
+     * from this point so the cursor stops advancing exactly at the last delivered
+     * event — the bridge keeps the turn running and the not-yet-delivered tail is
+     * replayed to the next process on `resume`.
+     */
+    this.suspended = false;
+    /** Channel is fully torn down; `send` throws and `onClose` has fired. */
+    this.terminal = false;
+    this._lastSeenEventId = 0;
+    this.pendingSends = [];
+    this.dispatchChain = Promise.resolve();
+    var _a, _b, _c, _d, _e, _f, _g;
+    this.connectThunk = options.connect;
+    this.outboundSchema = options.outboundSchema;
+    this.onDebug = options.onDebug;
+    this.onDiagnostic = options.onDiagnostic;
+    this.onBridgeError = options.onBridgeError;
+    this.maxElapsedMs = (_b = (_a = options.reconnect) == null ? void 0 : _a.maxElapsedMs) != null ? _b : 3e4;
+    this.initialDelayMs = (_d = (_c = options.reconnect) == null ? void 0 : _c.initialDelayMs) != null ? _d : 50;
+    this.maxDelayMs = (_f = (_e = options.reconnect) == null ? void 0 : _e.maxDelayMs) != null ? _f : 2e3;
+    this._lastSeenEventId = (_g = options.initialLastSeenEventId) != null ? _g : 0;
+  }
+  /**
+   * Highest bridge event `seq` this channel has observed. Persist it (e.g. via
+   * the adapter's resume handle) so a future process can seed
+   * {@link SandboxChannelOptions.initialLastSeenEventId} and attach.
+   */
+  get lastSeenEventId() {
+    return this._lastSeenEventId;
+  }
+  /**
+   * Establish the initial connection. A single attempt — startup failures
+   * reject so the caller can fail `doStart` cleanly. Reconnect retries apply
+   * only to drops after a successful open.
+   *
+   * Pass `{ resume: true }` to attach to a bridge that is already mid-session:
+   * after the socket opens, the channel sends `{ type: 'resume', lastSeenEventId }`
+   * so the bridge replays everything past the seeded cursor. This is the
+   * cross-process attach handshake — identical to what a transient reconnect
+   * does, but triggered by the initial open from a new process.
+   */
+  async open(opts) {
+    if (this.terminal) {
+      throw new Error("SandboxChannel: cannot open a closed channel.");
+    }
+    const ws = await this.connectThunk();
+    this.wire(ws);
+    this.ws = ws;
+    this.connected = true;
+    if (opts == null ? void 0 : opts.resume) {
+      this.rawSend(
+        JSON.stringify({
+          type: "resume",
+          lastSeenEventId: this._lastSeenEventId
+        })
+      );
+    }
+  }
+  on(type, listener) {
+    let set = this.listeners.get(type);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(type, set);
+    }
+    set.add(listener);
+    const buffered = this.buffered.get(type);
+    if (buffered) {
+      this.buffered.delete(type);
+      for (const event of buffered) {
+        listener(event);
+      }
+    }
+    return () => {
+      set.delete(listener);
+    };
+  }
+  onClose(handler) {
+    this.onCloseHandlers.add(handler);
+  }
+  send(message) {
+    if (this.terminal) {
+      throw new Error(
+        `SandboxChannel: cannot send ${message.type} \u2014 channel is closed.`
+      );
+    }
+    this.rawSend(JSON.stringify(message));
+  }
+  /**
+   * Mark that the host is tearing the session down. The next socket close is
+   * then treated as terminal rather than triggering a reconnect. Call before
+   * sending a `shutdown` / `detach` message whose ack the bridge follows with a
+   * socket close.
+   */
+  beginClose() {
+    this.closing = true;
+  }
+  close() {
+    var _a;
+    if (this.terminal) return;
+    this.closing = true;
+    try {
+      (_a = this.ws) == null ? void 0 : _a.close();
+    } catch (e) {
+    }
+    this.enqueue(() => this.finalizeClose(1e3, "closed"));
+  }
+  interrupt(options) {
+    var _a;
+    const timeoutMs = (_a = options == null ? void 0 : options.timeoutMs) != null ? _a : 5e3;
+    return new Promise((resolve, reject) => {
+      var _a2;
+      let settled = false;
+      let unsub = () => {
+      };
+      const timer = setTimeout(() => {
+        complete(
+          new Error(
+            `SandboxChannel: interrupt was not acknowledged within ${timeoutMs}ms.`
+          )
+        );
+      }, timeoutMs);
+      (_a2 = timer.unref) == null ? void 0 : _a2.call(timer);
+      const complete = (error) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        unsub();
+        if (error) {
+          reject(error);
+        } else {
+          resolve();
+        }
+      };
+      unsub = this.on("bridge-interrupted", (event) => {
+        const response = event;
+        if (response.ok) {
+          complete();
+          return;
+        }
+        complete(
+          new Error(
+            `SandboxChannel: interrupt failed: ${formatControlError(
+              response.error
+            )}`
+          )
+        );
+      });
+      try {
+        this.send({ type: "interrupt" });
+      } catch (err) {
+        complete(err);
+      }
+    });
+  }
+  /**
+   * Gracefully suspend at a slice boundary: stop processing inbound frames
+   * (so the cursor freezes at the last delivered event), drain any frames
+   * already queued for dispatch, then close the socket and finalise with the
+   * close reason `'suspended'`. Resolves with the final `lastSeenEventId`.
+   *
+   * The bridge keeps the in-flight turn running (a host socket close never
+   * aborts it) and accumulates events past the cursor for the next process to
+   * `resume`. Unlike {@link close}, the consumer's active turn is wound down
+   * cleanly — adapters distinguish a suspend from an unexpected drop via the
+   * `'suspended'` close reason and resolve `done` successfully.
+   */
+  suspend() {
+    return new Promise((resolve) => {
+      if (this.terminal) {
+        resolve(this._lastSeenEventId);
+        return;
+      }
+      this.suspended = true;
+      this.closing = true;
+      this.onClose(() => resolve(this._lastSeenEventId));
+      this.enqueue(() => {
+        var _a;
+        try {
+          (_a = this.ws) == null ? void 0 : _a.close();
+        } catch (e) {
+        }
+        this.finalizeClose(1e3, "suspended");
+      });
+    });
+  }
+  isClosed() {
+    return this.terminal;
+  }
+  // ─── internals ──────────────────────────────────────────────────────
+  wire(ws) {
+    let dropped = false;
+    const onDrop = (code, reason) => {
+      if (dropped) return;
+      dropped = true;
+      if (ws !== this.ws) return;
+      this.connected = false;
+      if (this.closing) {
+        this.enqueue(() => this.finalizeClose(code, reason));
+      } else {
+        this.enqueue(() => this.reconnectLoop());
+      }
+    };
+    ws.on("message", (raw) => {
+      if (this.suspended) return;
+      const text = typeof raw === "string" ? raw : Buffer.from(raw).toString("utf8");
+      this.enqueue(() => this.handleIncoming(text));
+    });
+    ws.on(
+      "close",
+      (code, reason) => {
+        var _a, _b;
+        return onDrop(code, (_b = (_a = reason == null ? void 0 : reason.toString) == null ? void 0 : _a.call(reason, "utf8")) != null ? _b : "");
+      }
+    );
+    ws.on("error", () => onDrop(1006, "socket error"));
+  }
+  async reconnectLoop() {
+    var _a, _b, _c;
+    if (this.terminal || this.closing) return;
+    const start = Date.now();
+    let attempt = 0;
+    let delay = this.initialDelayMs;
+    while (!this.terminal && !this.closing) {
+      attempt++;
+      (_a = this.onDebug) == null ? void 0 : _a.call(this, {
+        event: "reconnect-attempt",
+        attempt,
+        lastSeenEventId: this._lastSeenEventId
+      });
+      try {
+        const ws = await this.connectThunk();
+        if (this.terminal || this.closing) {
+          try {
+            ws.close();
+          } catch (e) {
+          }
+          return;
+        }
+        this.wire(ws);
+        this.ws = ws;
+        this.connected = true;
+        this.rawSend(
+          JSON.stringify({
+            type: "resume",
+            lastSeenEventId: this._lastSeenEventId
+          })
+        );
+        this.flushPending();
+        (_b = this.onDebug) == null ? void 0 : _b.call(this, {
+          event: "reconnected",
+          attempt,
+          lastSeenEventId: this._lastSeenEventId
+        });
+        return;
+      } catch (cause) {
+        if (Date.now() - start >= this.maxElapsedMs) {
+          this.finalizeClose(1006, "reconnect failed");
+          (_c = this.onDebug) == null ? void 0 : _c.call(this, {
+            event: "reconnect-failed",
+            attempts: attempt,
+            lastSeenEventId: this._lastSeenEventId,
+            cause
+          });
+          return;
+        }
+        await sleep(delay);
+        delay = Math.min(delay * 1.5, this.maxDelayMs);
+      }
+    }
+  }
+  rawSend(text) {
+    if (this.connected && this.ws) {
+      this.ws.send(text);
+    } else {
+      this.pendingSends.push(text);
+    }
+  }
+  flushPending() {
+    if (!this.connected || !this.ws) return;
+    const queued = this.pendingSends.splice(0);
+    for (const text of queued) this.ws.send(text);
+  }
+  enqueue(work) {
+    this.dispatchChain = this.dispatchChain.then(work);
+  }
+  async handleIncoming(text) {
+    const raw = await safeParseJSON({ text });
+    let seq;
+    if (raw.success && raw.value != null && typeof raw.value === "object" && typeof raw.value.seq === "number") {
+      seq = raw.value.seq;
+    }
+    const validated = await safeValidateTypes({
+      value: raw.success ? raw.value : void 0,
+      schema: this.outboundSchema
+    });
+    if (validated.success) {
+      this.dispatch(validated.value);
+    } else {
+      this.dispatch({
+        type: "error",
+        error: validated.error
+      });
+    }
+    if (seq !== void 0 && seq > this._lastSeenEventId) {
+      this._lastSeenEventId = seq;
+    }
+  }
+  dispatch(message) {
+    var _a, _b;
+    if (message.type === "sandbox-log" || message.type === "debug-event") {
+      (_a = this.onDiagnostic) == null ? void 0 : _a.call(
+        this,
+        message
+      );
+      return;
+    }
+    if (message.type === "error") {
+      (_b = this.onBridgeError) == null ? void 0 : _b.call(this, message);
+    }
+    const type = message.type;
+    const set = this.listeners.get(type);
+    if (!set || set.size === 0) {
+      let bucket = this.buffered.get(type);
+      if (!bucket) {
+        bucket = [];
+        this.buffered.set(type, bucket);
+      }
+      bucket.push(message);
+      return;
+    }
+    for (const listener of set) {
+      listener(message);
+    }
+  }
+  finalizeClose(code, reason) {
+    if (this.terminal) return;
+    this.terminal = true;
+    this.connected = false;
+    for (const h of this.onCloseHandlers) h(code, reason);
+  }
+};
+function formatControlError(error) {
+  if (error instanceof Error) return error.message;
+  if (error && typeof error === "object") {
+    const message = error.message;
+    if (typeof message === "string" && message.length > 0) return message;
+  }
+  if (typeof error === "string" && error.length > 0) return error;
+  return "unknown error";
+}
+
+// src/utils/classify-disk-log.ts
+import { safeParseJSON as safeParseJSON2 } from "@ai-sdk/provider-utils";
+async function classifyDiskLog(eventLog) {
+  if (!eventLog) return "rerun";
+  const lines = eventLog.split("\n").map((line) => line.trim()).filter(Boolean);
+  const lastLine = lines.at(-1);
+  if (lastLine == null) return "rerun";
+  const parsed = await safeParseJSON2({ text: lastLine });
+  if (parsed.success && parsed.value != null && typeof parsed.value === "object" && parsed.value.type === "finish") {
+    return "replay";
+  }
+  return "rerun";
+}
+
+// src/utils/ai-gateway-auth.ts
+var DEFAULT_AI_GATEWAY_BASE_URL = "https://ai-gateway.vercel.sh";
+function getAiGatewayAuthFromEnv({
+  env
+}) {
+  var _a;
+  return {
+    apiKey: env.AI_GATEWAY_API_KEY || env.VERCEL_OIDC_TOKEN || void 0,
+    baseUrl: (_a = env.AI_GATEWAY_BASE_URL) != null ? _a : DEFAULT_AI_GATEWAY_BASE_URL
+  };
+}
+
+// src/utils/sandbox-home-dir.ts
+import path from "path";
+async function resolveSandboxHomeDir({
+  sandbox,
+  abortSignal
+}) {
+  const result = await sandbox.run({
+    command: 'printf "%s" "$HOME"',
+    abortSignal
+  });
+  const homeDir = result.stdout.trim();
+  if (result.exitCode !== 0 || !homeDir || !path.posix.isAbsolute(homeDir)) {
+    throw new Error(
+      `Unable to resolve sandbox HOME directory: ${result.stderr || result.stdout}`
+    );
+  }
+  return homeDir;
+}
+
+// src/utils/shell-quote.ts
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+
+// src/utils/write-skills.ts
+import path2 from "path";
+async function writeSkills({
+  sandbox,
+  rootDir,
+  skills,
+  abortSignal,
+  skillNamePattern = /^[A-Za-z0-9._-]+$/,
+  invalidSkillNameMessage = ({ name }) => `Invalid skill name: ${name}`,
+  filePathMode = "relative",
+  invalidSkillFilePathMessage = ({ skillName, filePath }) => `Invalid skill file path for ${skillName}: ${filePath}`,
+  trailingNewline = false
+}) {
+  var _a, _b;
+  for (const skill of skills) {
+    validateSkillName({
+      name: skill.name,
+      pattern: skillNamePattern,
+      message: invalidSkillNameMessage
+    });
+    for (const file of (_a = skill.files) != null ? _a : []) {
+      normalizeSkillFilePath({
+        skillName: skill.name,
+        filePath: file.path,
+        mode: filePathMode,
+        message: invalidSkillFilePathMessage
+      });
+    }
+  }
+  await sandbox.run({
+    command: `mkdir -p ${shellQuote(rootDir)}`,
+    abortSignal
+  });
+  for (const skill of skills) {
+    const name = validateSkillName({
+      name: skill.name,
+      pattern: skillNamePattern,
+      message: invalidSkillNameMessage
+    });
+    const skillDir = path2.posix.join(rootDir, name);
+    await sandbox.writeTextFile({
+      path: path2.posix.join(skillDir, "SKILL.md"),
+      content: renderSkillFile({ skill, trailingNewline }),
+      abortSignal
+    });
+    for (const file of (_b = skill.files) != null ? _b : []) {
+      const filePath = normalizeSkillFilePath({
+        skillName: skill.name,
+        filePath: file.path,
+        mode: filePathMode,
+        message: invalidSkillFilePathMessage
+      });
+      await sandbox.writeTextFile({
+        path: path2.posix.join(skillDir, filePath),
+        content: file.content,
+        abortSignal
+      });
+    }
+  }
+}
+function validateSkillName({
+  name,
+  pattern,
+  message
+}) {
+  var _a;
+  if (!pattern.test(name) || name === "." || name === "..") {
+    throw new Error((_a = message == null ? void 0 : message({ name })) != null ? _a : `Invalid skill name: ${name}`);
+  }
+  return name;
+}
+function normalizeSkillFilePath({
+  skillName,
+  filePath,
+  mode,
+  message
+}) {
+  var _a;
+  const normalized = mode === "strip-leading-slashes" ? filePath.replace(/^\/+/, "") : path2.posix.normalize(filePath);
+  const invalid = normalized === "" || mode === "relative" && normalized === "." || normalized.startsWith("../") || normalized.includes("/../") || normalized.endsWith("/..") || mode === "relative" && path2.posix.isAbsolute(normalized);
+  if (invalid) {
+    throw new Error(
+      (_a = message == null ? void 0 : message({ skillName: skillName != null ? skillName : "", filePath })) != null ? _a : `Invalid skill file path for ${skillName}: ${filePath}`
+    );
+  }
+  return normalized;
+}
+function renderSkillFile({
+  skill,
+  trailingNewline
+}) {
+  const content = `---
+name: ${skill.name}
+description: ${skill.description}
+---
+
+${skill.content}`;
+  return trailingNewline ? `${content}
+` : content;
+}
+
+// src/utils/bridge-ready.ts
+import {
+  safeParseJSON as safeParseJSON3
+} from "@ai-sdk/provider-utils";
+import { z as z4 } from "zod/v4";
+
+// src/v1/harness-v1-bridge-protocol.ts
+import { z as z3 } from "zod/v4";
+
+// src/v1/harness-v1-diagnostic.ts
+import { z } from "zod/v4";
+var harnessV1DebugLevelSchema = z.enum([
+  "error",
+  "warn",
+  "info",
+  "debug",
+  "trace"
+]);
+var harnessV1DebugConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  level: harnessV1DebugLevelSchema.optional(),
+  subsystems: z.array(z.string()).optional()
+});
+
+// src/v1/harness-v1-stream-part.ts
+import { z as z2 } from "zod/v4";
+var harnessV1JsonValueSchema = z2.lazy(
+  () => z2.union([
+    z2.string(),
+    z2.number(),
+    z2.boolean(),
+    z2.null(),
+    z2.array(harnessV1JsonValueSchema),
+    z2.record(z2.string(), harnessV1JsonValueSchema)
+  ])
+);
+var harnessV1ToolResultValueSchema = harnessV1JsonValueSchema;
+var harnessV1JsonObjectSchema = z2.record(
+  z2.string(),
+  harnessV1JsonValueSchema
+);
+var harnessV1MetadataSchema = z2.record(
+  z2.string(),
+  z2.record(z2.string(), harnessV1JsonValueSchema)
+);
+var harnessV1ProviderMetadataSchema = z2.record(
+  z2.string(),
+  z2.record(z2.string(), harnessV1JsonValueSchema)
+);
+var harnessV1CallWarningSchema = z2.union([
+  z2.object({
+    type: z2.literal("unsupported-setting"),
+    setting: z2.string(),
+    details: z2.string().optional()
+  }),
+  z2.object({
+    type: z2.literal("unsupported-tool"),
+    tool: z2.string(),
+    details: z2.string().optional()
+  }),
+  z2.object({ type: z2.literal("other"), message: z2.string() })
+]);
+var harnessV1UsageSchema = z2.object({
+  inputTokens: z2.object({
+    total: z2.number().optional(),
+    noCache: z2.number().optional(),
+    cacheRead: z2.number().optional(),
+    cacheWrite: z2.number().optional()
+  }),
+  outputTokens: z2.object({
+    total: z2.number().optional(),
+    text: z2.number().optional(),
+    reasoning: z2.number().optional()
+  }),
+  raw: harnessV1JsonObjectSchema.optional()
+});
+var harnessV1FinishReasonSchema = z2.object({
+  unified: z2.enum([
+    "stop",
+    "length",
+    "content-filter",
+    "tool-calls",
+    "error",
+    "other"
+  ]),
+  raw: z2.string().optional()
+});
+var harnessV1StreamStartPartSchema = z2.object({
+  type: z2.literal("stream-start"),
+  warnings: z2.array(harnessV1CallWarningSchema).readonly().optional(),
+  modelId: z2.string().optional()
+});
+var harnessV1TextStartPartSchema = z2.object({
+  type: z2.literal("text-start"),
+  id: z2.string(),
+  harnessMetadata: harnessV1MetadataSchema.optional()
+});
+var harnessV1TextDeltaPartSchema = z2.object({
+  type: z2.literal("text-delta"),
+  id: z2.string(),
+  delta: z2.string(),
+  harnessMetadata: harnessV1MetadataSchema.optional()
+});
+var harnessV1TextEndPartSchema = z2.object({
+  type: z2.literal("text-end"),
+  id: z2.string(),
+  harnessMetadata: harnessV1MetadataSchema.optional()
+});
+var harnessV1ReasoningStartPartSchema = z2.object({
+  type: z2.literal("reasoning-start"),
+  id: z2.string(),
+  harnessMetadata: harnessV1MetadataSchema.optional()
+});
+var harnessV1ReasoningDeltaPartSchema = z2.object({
+  type: z2.literal("reasoning-delta"),
+  id: z2.string(),
+  delta: z2.string(),
+  harnessMetadata: harnessV1MetadataSchema.optional()
+});
+var harnessV1ReasoningEndPartSchema = z2.object({
+  type: z2.literal("reasoning-end"),
+  id: z2.string(),
+  harnessMetadata: harnessV1MetadataSchema.optional()
+});
+var harnessV1ToolCallPartSchema = z2.object({
+  type: z2.literal("tool-call"),
+  toolCallId: z2.string(),
+  toolName: z2.string(),
+  input: z2.string(),
+  providerExecuted: z2.boolean().optional(),
+  dynamic: z2.boolean().optional(),
+  providerMetadata: harnessV1ProviderMetadataSchema.optional(),
+  nativeName: z2.string().optional()
+});
+var harnessV1ToolApprovalRequestPartSchema = z2.object({
+  type: z2.literal("tool-approval-request"),
+  approvalId: z2.string(),
+  toolCallId: z2.string(),
+  providerMetadata: harnessV1ProviderMetadataSchema.optional()
+});
+var harnessV1ToolResultPartSchema = z2.object({
+  type: z2.literal("tool-result"),
+  toolCallId: z2.string(),
+  toolName: z2.string(),
+  result: harnessV1ToolResultValueSchema,
+  isError: z2.boolean().optional(),
+  preliminary: z2.boolean().optional(),
+  dynamic: z2.boolean().optional(),
+  providerMetadata: harnessV1ProviderMetadataSchema.optional()
+});
+var harnessV1FinishStepPartSchema = z2.object({
+  type: z2.literal("finish-step"),
+  finishReason: harnessV1FinishReasonSchema,
+  usage: harnessV1UsageSchema,
+  harnessMetadata: harnessV1MetadataSchema.optional()
+});
+var harnessV1FinishPartSchema = z2.object({
+  type: z2.literal("finish"),
+  finishReason: harnessV1FinishReasonSchema,
+  totalUsage: harnessV1UsageSchema,
+  harnessMetadata: harnessV1MetadataSchema.optional()
+});
+var harnessV1FileChangePartSchema = z2.object({
+  type: z2.literal("file-change"),
+  event: z2.enum(["create", "modify", "delete"]),
+  path: z2.string(),
+  harnessMetadata: harnessV1MetadataSchema.optional()
+});
+var harnessV1CompactionPartSchema = z2.object({
+  type: z2.literal("compaction"),
+  trigger: z2.enum(["manual", "auto"]),
+  summary: z2.string(),
+  tokensBefore: z2.number().optional(),
+  tokensAfter: z2.number().optional(),
+  harnessMetadata: harnessV1MetadataSchema.optional()
+});
+var harnessV1ErrorPartSchema = z2.object({
+  type: z2.literal("error"),
+  error: z2.unknown()
+});
+var harnessV1RawPartSchema = z2.object({
+  type: z2.literal("raw"),
+  rawValue: z2.unknown()
+});
+var harnessV1StreamPartSchema = z2.discriminatedUnion("type", [
+  harnessV1StreamStartPartSchema,
+  harnessV1TextStartPartSchema,
+  harnessV1TextDeltaPartSchema,
+  harnessV1TextEndPartSchema,
+  harnessV1ReasoningStartPartSchema,
+  harnessV1ReasoningDeltaPartSchema,
+  harnessV1ReasoningEndPartSchema,
+  harnessV1ToolCallPartSchema,
+  harnessV1ToolApprovalRequestPartSchema,
+  harnessV1ToolResultPartSchema,
+  harnessV1FinishStepPartSchema,
+  harnessV1FinishPartSchema,
+  harnessV1FileChangePartSchema,
+  harnessV1CompactionPartSchema,
+  harnessV1ErrorPartSchema,
+  harnessV1RawPartSchema
+]);
+
+// src/v1/harness-v1-bridge-protocol.ts
+var harnessV1BridgeToolWireSchema = z3.object({
+  name: z3.string(),
+  description: z3.string().optional(),
+  inputSchema: z3.unknown().optional()
+});
+var harnessV1BridgePermissionModeSchema = z3.enum([
+  "allow-reads",
+  "allow-edits",
+  "allow-all"
+]);
+var harnessV1BridgeBuiltinToolFilteringSchema = z3.discriminatedUnion(
+  "mode",
+  [
+    z3.object({
+      mode: z3.literal("allow"),
+      toolNames: z3.array(z3.string())
+    }),
+    z3.object({
+      mode: z3.literal("deny"),
+      toolNames: z3.array(z3.string())
+    })
+  ]
+);
+var harnessV1BridgeStartBaseSchema = z3.object({
+  type: z3.literal("start"),
+  prompt: z3.string(),
+  tools: z3.array(harnessV1BridgeToolWireSchema).optional(),
+  model: z3.string().optional(),
+  debug: harnessV1DebugConfigSchema.optional(),
+  permissionMode: harnessV1BridgePermissionModeSchema.optional(),
+  builtinToolFiltering: harnessV1BridgeBuiltinToolFilteringSchema.optional()
+});
+var harnessV1BridgeHelloSchema = z3.object({
+  type: z3.literal("bridge-hello"),
+  state: z3.string().optional(),
+  lastSeq: z3.number().optional()
+});
+var harnessV1BridgeDetachSchema = z3.object({
+  type: z3.literal("bridge-detach"),
+  data: z3.unknown()
+});
+var harnessV1BridgeThreadSchema = z3.object({
+  type: z3.literal("bridge-thread"),
+  threadId: z3.string()
+});
+var harnessV1BridgeInterruptedSchema = z3.object({
+  type: z3.literal("bridge-interrupted"),
+  ok: z3.boolean(),
+  error: z3.unknown().optional()
+});
+var harnessV1BridgeSandboxLogSchema = z3.object({
+  type: z3.literal("sandbox-log"),
+  source: z3.string(),
+  stream: z3.enum(["stdout", "stderr"]),
+  line: z3.string()
+});
+var harnessV1BridgeDebugEventSchema = z3.object({
+  type: z3.literal("debug-event"),
+  level: harnessV1DebugLevelSchema,
+  subsystem: z3.string(),
+  message: z3.string(),
+  attrs: z3.record(z3.string(), z3.unknown()).optional(),
+  error: z3.object({
+    name: z3.string().optional(),
+    message: z3.string(),
+    stack: z3.string().optional()
+  }).optional()
+});
+var harnessV1BridgeOutboundMessageSchema = z3.discriminatedUnion(
+  "type",
+  [
+    harnessV1StreamStartPartSchema,
+    harnessV1TextStartPartSchema,
+    harnessV1TextDeltaPartSchema,
+    harnessV1TextEndPartSchema,
+    harnessV1ReasoningStartPartSchema,
+    harnessV1ReasoningDeltaPartSchema,
+    harnessV1ReasoningEndPartSchema,
+    harnessV1ToolCallPartSchema,
+    harnessV1ToolApprovalRequestPartSchema,
+    harnessV1ToolResultPartSchema,
+    harnessV1FinishStepPartSchema,
+    harnessV1FinishPartSchema,
+    harnessV1FileChangePartSchema,
+    harnessV1CompactionPartSchema,
+    harnessV1ErrorPartSchema,
+    harnessV1RawPartSchema,
+    harnessV1BridgeHelloSchema,
+    harnessV1BridgeDetachSchema,
+    harnessV1BridgeThreadSchema,
+    harnessV1BridgeInterruptedSchema,
+    harnessV1BridgeSandboxLogSchema,
+    harnessV1BridgeDebugEventSchema
+  ]
+);
+var harnessV1BridgeToolResultInboundSchema = z3.object({
+  type: z3.literal("tool-result"),
+  toolCallId: z3.string(),
+  output: z3.unknown(),
+  isError: z3.boolean().optional()
+});
+var harnessV1BridgeToolApprovalResponseInboundSchema = z3.object({
+  type: z3.literal("tool-approval-response"),
+  approvalId: z3.string(),
+  approved: z3.boolean(),
+  reason: z3.string().optional()
+});
+var harnessV1BridgeUserMessageInboundSchema = z3.object({
+  type: z3.literal("user-message"),
+  text: z3.string()
+});
+var harnessV1BridgeAbortInboundSchema = z3.object({
+  type: z3.literal("abort")
+});
+var harnessV1BridgeInterruptInboundSchema = z3.object({
+  type: z3.literal("interrupt")
+});
+var harnessV1BridgeShutdownInboundSchema = z3.object({
+  type: z3.literal("shutdown")
+});
+var harnessV1BridgeResumeInboundSchema = z3.object({
+  type: z3.literal("resume"),
+  lastSeenEventId: z3.number()
+});
+var harnessV1BridgeDetachInboundSchema = z3.object({
+  type: z3.literal("detach")
+});
+var harnessV1BridgeReadySchema = z3.object({
+  type: z3.literal("bridge-ready"),
+  port: z3.number()
+});
+
+// src/utils/bridge-ready.ts
+var bridgeMetaSchema = z4.object({
+  type: z4.string().optional(),
+  port: z4.number().optional(),
+  state: z4.string().optional(),
+  pid: z4.number().optional()
+});
+async function markBridgeStarting({
+  sandbox,
+  bridgeStateDir,
+  bridgeType,
+  abortSignal
+}) {
+  try {
+    await sandbox.writeTextFile({
+      path: bridgeMetaPath(bridgeStateDir),
+      content: JSON.stringify({ type: bridgeType, state: "starting" }),
+      abortSignal
+    });
+  } catch (e) {
+  }
+}
+async function waitForBridgeReady({
+  proc,
+  sandbox,
+  bridgeStateDir,
+  bridgeType,
+  timeoutMs,
+  abortSignal,
+  pollIntervalMs = 100,
+  createTimeoutError,
+  createExitError
+}) {
+  var _a;
+  const reader = proc.stdout.pipeThrough(new TextDecoderStream()).getReader();
+  const decoder = lineDecoder();
+  const stdoutTail = [];
+  const deadline = Date.now() + timeoutMs;
+  let pendingStdoutRead;
+  let pendingMetaRead;
+  let nextMetaReadAt = 0;
+  let cancelReader = false;
+  try {
+    while (true) {
+      if (abortSignal == null ? void 0 : abortSignal.aborted) {
+        cancelReader = true;
+        await proc.kill();
+        throw (_a = abortSignal.reason) != null ? _a : new DOMException("Aborted", "AbortError");
+      }
+      const remaining = deadline - Date.now();
+      if (remaining <= 0) {
+        cancelReader = true;
+        await proc.kill();
+        throw await makeBridgeReadyError({
+          createError: createTimeoutError,
+          fallbackMessage: "bridge did not become ready in time.",
+          proc,
+          stdoutTail
+        });
+      }
+      pendingStdoutRead != null ? pendingStdoutRead : pendingStdoutRead = reader.read();
+      const metaReadDelayMs = Math.max(0, nextMetaReadAt - Date.now());
+      if (pendingMetaRead === void 0 && metaReadDelayMs === 0) {
+        pendingMetaRead = readBridgeMetaReady({
+          sandbox,
+          bridgeStateDir,
+          bridgeType,
+          abortSignal
+        });
+      }
+      const result = await Promise.race([
+        pendingStdoutRead.then((read) => ({ source: "stdout", read })),
+        ...pendingMetaRead === void 0 ? [] : [
+          pendingMetaRead.then((port) => ({
+            source: "metadata",
+            port
+          }))
+        ],
+        sleep2(
+          Math.min(
+            remaining,
+            pendingMetaRead === void 0 ? metaReadDelayMs : pollIntervalMs
+          )
+        ).then(() => void 0)
+      ]);
+      if (result === void 0) continue;
+      if (result.source === "metadata") {
+        pendingMetaRead = void 0;
+        if (result.port !== void 0) {
+          cancelReader = true;
+          return {
+            port: result.port,
+            source: "metadata",
+            stdoutTail: [...stdoutTail]
+          };
+        }
+        nextMetaReadAt = Date.now() + pollIntervalMs;
+        continue;
+      }
+      pendingStdoutRead = void 0;
+      const { value, done } = result.read;
+      if (done) {
+        for (const line of decoder.flush()) {
+          pushTail({ lines: stdoutTail, line });
+        }
+        throw await makeBridgeReadyError({
+          createError: createExitError,
+          fallbackMessage: "bridge exited before becoming ready.",
+          proc,
+          stdoutTail
+        });
+      }
+      if (value === void 0) continue;
+      for (const line of decoder.push(value)) {
+        pushTail({ lines: stdoutTail, line });
+        const parsed = await safeParseJSON3({
+          text: line,
+          schema: harnessV1BridgeReadySchema
+        });
+        if (parsed.success) {
+          return {
+            port: parsed.value.port,
+            source: "stdout",
+            stdoutTail: [...stdoutTail]
+          };
+        }
+      }
+    }
+  } finally {
+    if (cancelReader) {
+      await Promise.race([reader.cancel().catch(() => {
+      }), sleep2(100)]);
+    }
+    try {
+      reader.releaseLock();
+    } catch (e) {
+    }
+  }
+}
+async function readBridgeMetaReady({
+  sandbox,
+  bridgeStateDir,
+  bridgeType,
+  abortSignal
+}) {
+  const raw = await Promise.resolve(
+    sandbox.readTextFile({
+      path: bridgeMetaPath(bridgeStateDir),
+      abortSignal
+    })
+  ).catch(() => null);
+  if (raw == null) return void 0;
+  const parsed = await safeParseJSON3({ text: raw, schema: bridgeMetaSchema });
+  if (!parsed.success) return void 0;
+  if (parsed.value.type !== bridgeType) return void 0;
+  if (parsed.value.state !== "waiting") return void 0;
+  if (parsed.value.port === void 0 || parsed.value.port <= 0) {
+    return void 0;
+  }
+  return parsed.value.port;
+}
+async function makeBridgeReadyError({
+  createError,
+  fallbackMessage,
+  proc,
+  stdoutTail
+}) {
+  if (createError) {
+    return createError({ proc, stdoutTail: [...stdoutTail] });
+  }
+  return new Error(fallbackMessage);
+}
+function bridgeMetaPath(bridgeStateDir) {
+  return `${bridgeStateDir}/bridge-meta.json`;
+}
+function pushTail({ lines, line }) {
+  lines.push(line);
+  if (lines.length > 20) lines.shift();
+}
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function lineDecoder() {
+  let buffer = "";
+  return {
+    push(chunk) {
+      buffer += chunk;
+      const lines = [];
+      let nl;
+      while ((nl = buffer.indexOf("\n")) !== -1) {
+        const raw = buffer.slice(0, nl);
+        buffer = buffer.slice(nl + 1);
+        const line = raw.replace(/\r$/, "").trim();
+        if (line.length > 0) lines.push(line);
+      }
+      return lines;
+    },
+    flush() {
+      const line = buffer.replace(/\r$/, "").trim();
+      buffer = "";
+      return line.length > 0 ? [line] : [];
+    }
+  };
+}
+
+// src/utils/bridge-diagnostics.ts
+var DEFAULT_TAIL_LIMIT = 20;
+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 _a, _b;
+  if (error instanceof Error) {
+    return (_a = error.stack) != null ? _a : `${error.name}: ${error.message}`;
+  }
+  if (isSerializedError(error)) {
+    return (_b = error.stack) != null ? _b : `${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}
+`);
+    }
+  }
+}
+function createBridgeErrorHandler({
+  harnessId,
+  sessionId
+}) {
+  return (event) => {
+    logBridgeError({
+      harnessId,
+      sessionId,
+      context: "bridge emitted an error frame",
+      error: event.error
+    });
+  };
+}
+async function createBridgeStartupError({
+  message,
+  proc,
+  stdoutTail,
+  stderrTail,
+  stderrDone
+}) {
+  if (stderrDone) {
+    await Promise.race([stderrDone, sleep3(250)]).catch(() => {
+    });
+  }
+  let exitStatus = "";
+  try {
+    const result = await Promise.race([
+      proc.wait(),
+      sleep3(250).then(() => void 0)
+    ]);
+    if ((result == null ? void 0 : result.exitCode) !== void 0) {
+      exitStatus = ` Exit code: ${result.exitCode}.`;
+    }
+  } catch (e) {
+  }
+  const details = [];
+  if (stdoutTail.length > 0) {
+    details.push(`stdout:
+${stdoutTail.join("\n")}`);
+  }
+  if (stderrTail.length > 0) {
+    details.push(`stderr:
+${stderrTail.join("\n")}`);
+  }
+  return new Error(
+    `${message}${exitStatus}${details.length > 0 ? `
+
+${details.join("\n\n")}` : ""}`
+  );
+}
+async function forwardBridgeProcessStream({
+  stream,
+  streamName,
+  source = "bridge",
+  collectTail,
+  tailLimit = DEFAULT_TAIL_LIMIT
+}) {
+  try {
+    const reader = stream.pipeThrough(new TextDecoderStream()).getReader();
+    const decoder = lineDecoder2();
+    while (true) {
+      const { value, done } = await reader.read();
+      const lines = done ? decoder.flush() : value ? decoder.push(value) : [];
+      for (const line of lines) {
+        recordTail({ lines: collectTail, line, limit: tailLimit });
+        writeToStderr(`[harness:${source}:${streamName}] ${line}
+`);
+      }
+      if (done) return;
+    }
+  } catch (e) {
+  }
+}
+async function drainBridgeProcessStream(stream) {
+  try {
+    const reader = stream.pipeThrough(new TextDecoderStream()).getReader();
+    while (true) {
+      const { done } = await reader.read();
+      if (done) return;
+    }
+  } catch (e) {
+  }
+}
+function recordTail({
+  lines,
+  line,
+  limit
+}) {
+  if (!lines) return;
+  lines.push(line);
+  while (lines.length > limit) lines.shift();
+}
+function lineDecoder2() {
+  let buffer = "";
+  return {
+    push(chunk) {
+      buffer += chunk;
+      const lines = [];
+      let nl;
+      while ((nl = buffer.indexOf("\n")) !== -1) {
+        const raw = buffer.slice(0, nl);
+        buffer = buffer.slice(nl + 1);
+        const line = raw.replace(/\r$/, "").trim();
+        if (line.length > 0) lines.push(line);
+      }
+      return lines;
+    },
+    flush() {
+      const line = buffer.replace(/\r$/, "").trim();
+      buffer = "";
+      return line.length > 0 ? [line] : [];
+    }
+  };
+}
+function sleep3(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export {
+  SandboxChannel,
+  classifyDiskLog,
+  createBridgeErrorHandler,
+  createBridgeStartupError,
+  drainBridgeProcessStream,
+  formatBridgeError,
+  forwardBridgeProcessStream,
+  getAiGatewayAuthFromEnv,
+  logBridgeError,
+  markBridgeStarting,
+  resolveSandboxHomeDir,
+  shellQuote,
+  waitForBridgeReady,
+  writeSkills
+};
+//# sourceMappingURL=index.js.map