@ai-sdk/harness-pi 0.0.0 → 1.0.0-canary.1

package/dist/index.js

@@ -0,0 +1,2075 @@
+// src/pi-harness.ts
+import {
+  commonTool
+} from "@ai-sdk/harness";
+import { tool } from "@ai-sdk/provider-utils";
+import { z as z3 } from "zod";
+
+// src/pi-resume-state.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import path from "path";
+import { z } from "zod";
+var piResumeStateSchema = z.object({
+  sessionFileName: z.string().optional()
+}).passthrough();
+var PI_SESSIONS_DIR = ".pi-sessions";
+async function persistSessionFileToSandbox(args) {
+  const hostPath = path.join(args.hostSessionDir, args.sessionFileName);
+  const content = await readFile(hostPath);
+  const remotePath = path.posix.join(
+    args.sessionWorkDir,
+    PI_SESSIONS_DIR,
+    args.sessionFileName
+  );
+  await args.sandbox.run({
+    command: `mkdir -p ${path.posix.dirname(remotePath)}`,
+    ...args.abortSignal ? { abortSignal: args.abortSignal } : {}
+  });
+  await args.sandbox.writeBinaryFile({
+    path: remotePath,
+    content,
+    ...args.abortSignal ? { abortSignal: args.abortSignal } : {}
+  });
+}
+async function pullSessionFileFromSandbox(args) {
+  const remotePath = path.posix.join(
+    args.sessionWorkDir,
+    PI_SESSIONS_DIR,
+    args.sessionFileName
+  );
+  const bytes = await args.sandbox.readBinaryFile({
+    path: remotePath,
+    ...args.abortSignal ? { abortSignal: args.abortSignal } : {}
+  });
+  if (!bytes) return void 0;
+  await mkdir(args.hostSessionDir, { recursive: true });
+  const hostPath = path.join(args.hostSessionDir, args.sessionFileName);
+  await writeFile(hostPath, bytes);
+  return hostPath;
+}
+
+// src/pi-session.ts
+import {
+  AuthStorage,
+  createAgentSession,
+  DefaultResourceLoader,
+  defineTool,
+  ModelRegistry,
+  SessionManager,
+  SettingsManager
+} from "@earendil-works/pi-coding-agent";
+import { mkdir as mkdir3, rm as rm2 } from "fs/promises";
+import { tmpdir } from "os";
+import path7 from "path";
+import { Type as Type2 } from "typebox";
+
+// src/pi-auth.ts
+var DEFAULT_GATEWAY_BASE_URL = "https://ai-gateway.vercel.sh";
+var DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
+var DEFAULT_ANTHROPIC_BASE_URL = "https://api.anthropic.com";
+function register(registries, provider, apiKey, config) {
+  registries.authStorage.setRuntimeApiKey(provider, apiKey);
+  registries.modelRegistry.registerProvider(provider, config);
+}
+function hasConfiguredValue(value) {
+  if (value == null) return false;
+  if (typeof value === "string") return value.length > 0;
+  if (typeof value !== "object") return true;
+  return Object.values(value).some(hasConfiguredValue);
+}
+function resolvePiAuth(options, env, registries) {
+  const customEnvConfigured = hasConfiguredValue(options?.customEnv);
+  const gatewayConfigured = hasConfiguredValue(options?.gateway);
+  if (customEnvConfigured) {
+    return applyCustomEnv(options.customEnv ?? {}, registries);
+  }
+  if (gatewayConfigured) {
+    const apiKey = options.gateway?.apiKey;
+    const baseUrl = options.gateway?.baseUrl ?? DEFAULT_GATEWAY_BASE_URL;
+    if (apiKey) {
+      register(registries, "vercel-ai-gateway", apiKey, {
+        apiKey,
+        baseUrl,
+        authHeader: true
+      });
+      return { AI_GATEWAY_API_KEY: apiKey, AI_GATEWAY_BASE_URL: baseUrl };
+    }
+    return {};
+  }
+  const ambientKey = env.AI_GATEWAY_API_KEY || env.VERCEL_OIDC_TOKEN;
+  if (ambientKey) {
+    const baseUrl = env.AI_GATEWAY_BASE_URL ?? DEFAULT_GATEWAY_BASE_URL;
+    register(registries, "vercel-ai-gateway", ambientKey, {
+      apiKey: ambientKey,
+      baseUrl,
+      authHeader: true
+    });
+    return { AI_GATEWAY_API_KEY: ambientKey, AI_GATEWAY_BASE_URL: baseUrl };
+  }
+  return {};
+}
+function applyCustomEnv(customEnv, registries) {
+  const out = {};
+  const gatewayKey = customEnv.AI_GATEWAY_API_KEY;
+  if (gatewayKey) {
+    const baseUrl = customEnv.AI_GATEWAY_BASE_URL ?? DEFAULT_GATEWAY_BASE_URL;
+    register(registries, "vercel-ai-gateway", gatewayKey, {
+      apiKey: gatewayKey,
+      baseUrl,
+      authHeader: true
+    });
+    out.AI_GATEWAY_API_KEY = gatewayKey;
+    out.AI_GATEWAY_BASE_URL = baseUrl;
+  }
+  if (customEnv.OPENAI_API_KEY) {
+    const baseUrl = customEnv.OPENAI_BASE_URL ?? DEFAULT_OPENAI_BASE_URL;
+    register(registries, "openai", customEnv.OPENAI_API_KEY, {
+      apiKey: customEnv.OPENAI_API_KEY,
+      baseUrl,
+      authHeader: true
+    });
+  }
+  if (customEnv.ANTHROPIC_API_KEY) {
+    const baseUrl = customEnv.ANTHROPIC_BASE_URL ?? DEFAULT_ANTHROPIC_BASE_URL;
+    register(registries, "anthropic", customEnv.ANTHROPIC_API_KEY, {
+      apiKey: customEnv.ANTHROPIC_API_KEY,
+      baseUrl,
+      ...customEnv.ANTHROPIC_AUTH_TOKEN ? {
+        headers: {
+          authorization: `Bearer ${customEnv.ANTHROPIC_AUTH_TOKEN}`
+        }
+      } : {}
+    });
+  }
+  for (const [name, apiKey] of Object.entries(customEnv)) {
+    if (!name.endsWith("_API_KEY") || !apiKey) {
+      continue;
+    }
+    const prefix = name.slice(0, -"_API_KEY".length);
+    if (prefix === "AI_GATEWAY" || prefix === "OPENAI" || prefix === "ANTHROPIC") {
+      continue;
+    }
+    const provider = prefix.toLowerCase().replace(/_/g, "-");
+    const baseUrl = customEnv[`${prefix}_BASE_URL`];
+    if (!baseUrl) {
+      continue;
+    }
+    register(registries, provider, apiKey, {
+      apiKey,
+      baseUrl,
+      authHeader: true
+    });
+  }
+  return out;
+}
+
+// src/pi-events.ts
+import { z as z2 } from "zod";
+var piSessionEventSchema = z2.object({
+  type: z2.string(),
+  assistantMessageEvent: z2.object({
+    type: z2.string().optional(),
+    delta: z2.string().optional()
+  }).passthrough().optional(),
+  toolCallId: z2.string().optional(),
+  toolName: z2.string().optional(),
+  args: z2.unknown().optional(),
+  input: z2.unknown().optional(),
+  result: z2.unknown().optional(),
+  content: z2.unknown().optional(),
+  isError: z2.boolean().optional(),
+  // Compaction events (`compaction_start` / `compaction_end`). `result` (a
+  // `CompactionResult`) rides the shared `result` field above; `reason`
+  // distinguishes manual vs automatic (threshold/overflow) compaction.
+  reason: z2.string().optional(),
+  aborted: z2.boolean().optional(),
+  error: z2.union([
+    z2.string(),
+    z2.object({
+      errorMessage: z2.string().optional(),
+      stopReason: z2.string().optional()
+    }).passthrough()
+  ]).optional(),
+  message: z2.object({
+    role: z2.string().optional(),
+    content: z2.unknown().optional(),
+    stopReason: z2.string().optional(),
+    errorMessage: z2.string().optional()
+  }).passthrough().optional()
+}).passthrough();
+function parseNativeEvent(raw) {
+  const parsed = piSessionEventSchema.safeParse(raw);
+  return parsed.success ? parsed.data : void 0;
+}
+function getPiTerminalError(event) {
+  const isTerminalStopReason = (value) => value === "error" || value === "aborted";
+  if (typeof event.error === "string" && event.error.trim()) {
+    return event.error.trim();
+  }
+  if (event.error && typeof event.error === "object") {
+    const errorMessage = event.error.errorMessage?.trim();
+    if (errorMessage) {
+      return errorMessage;
+    }
+    const stopReason = event.error.stopReason?.trim();
+    if (isTerminalStopReason(stopReason)) {
+      return stopReason;
+    }
+  }
+  const messageError = event.message?.errorMessage?.trim();
+  if (messageError) {
+    return messageError;
+  }
+  const messageStopReason = event.message?.stopReason?.trim();
+  if (isTerminalStopReason(messageStopReason)) {
+    return messageStopReason;
+  }
+  if (event.isError && typeof event.content === "string" && event.content.trim()) {
+    return event.content.trim();
+  }
+  return void 0;
+}
+function extractAssistantText(message) {
+  if (!message || message.role !== "assistant") {
+    return "";
+  }
+  if (typeof message.content === "string") {
+    return message.content;
+  }
+  if (!Array.isArray(message.content)) {
+    return "";
+  }
+  return message.content.flatMap((part) => {
+    if (!part || typeof part !== "object") {
+      return [];
+    }
+    const contentPart = part;
+    return contentPart.type === "text" && typeof contentPart.text === "string" ? [contentPart.text] : [];
+  }).join("");
+}
+
+// src/pi-model-resolver.ts
+var DEFAULT_PI_GATEWAY_MODEL_ID = "anthropic/claude-sonnet-4.6";
+function createPiModelResolver(modelRegistry, env = process.env) {
+  let cachedModels;
+  const loadModels = () => {
+    if (cachedModels) {
+      return cachedModels;
+    }
+    try {
+      cachedModels = modelRegistry.getAll();
+    } catch {
+      cachedModels = [];
+    }
+    return cachedModels;
+  };
+  return (modelId) => {
+    const useGateway = Boolean(env.AI_GATEWAY_API_KEY || env.VERCEL_OIDC_TOKEN);
+    const effectiveId = modelId ?? (useGateway ? DEFAULT_PI_GATEWAY_MODEL_ID : void 0);
+    if (!effectiveId) return void 0;
+    const models = loadModels();
+    const matches = (m) => m.id === effectiveId || m.name === effectiveId;
+    return useGateway && models.find((m) => m.provider === "vercel-ai-gateway" && matches(m)) || models.find(matches);
+  };
+}
+
+// src/pi-paths.ts
+import { realpathSync } from "fs";
+import path2 from "path";
+function isInsidePath(parent, candidate) {
+  const relative = path2.relative(parent, candidate);
+  return relative === "" || !relative.startsWith("..") && !path2.isAbsolute(relative);
+}
+function isInsidePosixPath(parent, candidate) {
+  const relative = path2.posix.relative(parent, candidate);
+  return relative === "" || !relative.startsWith("..") && !path2.posix.isAbsolute(relative);
+}
+function canonicalizeForContainment(inputPath) {
+  try {
+    return realpathSync.native(inputPath);
+  } catch {
+    const parent = path2.dirname(inputPath);
+    if (parent === inputPath) {
+      return inputPath;
+    }
+    return path2.join(
+      canonicalizeForContainment(parent),
+      path2.basename(inputPath)
+    );
+  }
+}
+function createPiPathMapper(hostWorkDir, sandboxWorkDir) {
+  const normalizedHost = path2.resolve(hostWorkDir);
+  const normalizedSandbox = path2.posix.normalize(sandboxWorkDir);
+  const canonicalHost = canonicalizeForContainment(normalizedHost);
+  return {
+    hostWorkDir: normalizedHost,
+    sandboxWorkDir: normalizedSandbox,
+    toSandboxPath(inputPath) {
+      if (path2.posix.isAbsolute(inputPath)) {
+        const normalizedInput = path2.posix.normalize(inputPath);
+        if (isInsidePosixPath(normalizedSandbox, normalizedInput)) {
+          return normalizedInput;
+        }
+      }
+      const resolvedHost = path2.isAbsolute(inputPath) ? path2.resolve(inputPath) : path2.resolve(normalizedHost, inputPath);
+      const canonicalResolvedHost = canonicalizeForContainment(resolvedHost);
+      if (!isInsidePath(normalizedHost, resolvedHost) || !isInsidePath(canonicalHost, canonicalResolvedHost)) {
+        throw new Error(`Pi path escapes the workspace: ${inputPath}`);
+      }
+      const relative = path2.relative(normalizedHost, resolvedHost).split(path2.sep).join("/");
+      return relative ? path2.posix.join(normalizedSandbox, relative) : normalizedSandbox;
+    },
+    toRelativePath(inputPath) {
+      const sandboxPath = path2.posix.isAbsolute(inputPath) ? path2.posix.normalize(inputPath) : path2.posix.join(
+        normalizedSandbox,
+        inputPath.split(path2.sep).join("/")
+      );
+      const relative = path2.posix.relative(normalizedSandbox, sandboxPath);
+      return relative || ".";
+    }
+  };
+}
+
+// src/pi-remote-ops.ts
+import path3 from "path";
+
+// src/pi-utils.ts
+import {
+  HarnessCapabilityUnsupportedError
+} from "@ai-sdk/harness";
+var HARNESS_ID = "pi";
+function extractUserText(prompt) {
+  if (typeof prompt === "string") {
+    return prompt;
+  }
+  const { content } = prompt;
+  if (typeof content === "string") {
+    return content;
+  }
+  const parts = [];
+  for (const part of content) {
+    if (part.type !== "text") {
+      throw new HarnessCapabilityUnsupportedError({
+        message: `pi: only text user-message parts are supported; got '${part.type}'.`,
+        harnessId: HARNESS_ID
+      });
+    }
+    parts.push(part.text);
+  }
+  return parts.join("\n\n");
+}
+function frameInstructions(instructions, userText) {
+  return `<session-instructions>
+The block below is operating guidance from the system, not a message from the user \u2014 follow it, but do not mention it or attribute it to the user.
+
+${instructions}
+</session-instructions>
+
+<user-message>
+${userText}
+</user-message>`;
+}
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function serializeToolOutput(output) {
+  if (typeof output === "string") {
+    return output;
+  }
+  const serialized = JSON.stringify(output);
+  return serialized ?? "null";
+}
+function safePiMetadataSegment(name, label) {
+  if (!/^[A-Za-z0-9._-]+$/.test(name) || name === "." || name === "..") {
+    throw new Error(`Invalid Pi ${label} name: ${name}`);
+  }
+  return name;
+}
+function renderPiSkillFile(skill) {
+  return `---
+name: ${skill.name}
+description: ${skill.description}
+---
+
+${skill.content}`;
+}
+
+// src/pi-remote-ops.ts
+function createPiRemoteOps(options) {
+  const runShell = async (command, input = {}) => {
+    const result = await options.sandbox.run({
+      command,
+      ...input.cwd ? { workingDirectory: options.paths.toSandboxPath(input.cwd) } : {},
+      ...options.env ? { env: options.env } : {},
+      ...input.signal ? { abortSignal: input.signal } : {}
+    });
+    const combined = `${result.stdout}${result.stderr}`;
+    const output = Buffer.from(combined, "utf8");
+    if (output.length > 0) {
+      input.onData?.(output);
+    }
+    return {
+      exitCode: result.exitCode,
+      output
+    };
+  };
+  const readBuffer = async (inputPath) => {
+    const bytes = await options.sandbox.readBinaryFile({
+      path: options.paths.toSandboxPath(inputPath)
+    });
+    if (!bytes) {
+      throw new Error(`Path not found: ${inputPath}`);
+    }
+    return Buffer.from(bytes);
+  };
+  const writeFile3 = async (inputPath, content) => {
+    const remotePath = options.paths.toSandboxPath(inputPath);
+    const previous = await options.sandbox.readBinaryFile({ path: remotePath });
+    await runShell(`mkdir -p ${shellQuote(path3.posix.dirname(remotePath))}`);
+    await options.sandbox.writeTextFile({ path: remotePath, content });
+    options.onFileChange?.(
+      previous ? "modify" : "create",
+      options.paths.toRelativePath(remotePath),
+      Buffer.from(content, "utf8")
+    );
+  };
+  const editFile = async (inputPath, oldText, newText) => {
+    const current = (await readBuffer(inputPath)).toString("utf8");
+    const index = current.indexOf(oldText);
+    if (index === -1) {
+      throw new Error(`Text to replace was not found in ${inputPath}`);
+    }
+    const updated = `${current.slice(0, index)}${newText}${current.slice(
+      index + oldText.length
+    )}`;
+    await writeFile3(inputPath, updated);
+    return updated;
+  };
+  const listDirectory = async (inputPath = ".", limit = 500) => {
+    const remotePath = options.paths.toSandboxPath(inputPath);
+    const result = await runShell(
+      [
+        `if [ ! -e ${shellQuote(remotePath)} ]; then echo "__PI_LS_NOT_FOUND__"; exit 2; fi`,
+        `if [ ! -d ${shellQuote(remotePath)} ]; then echo "__PI_LS_NOT_DIR__"; exit 3; fi`,
+        `cd ${shellQuote(remotePath)}`,
+        "ls -1Ap"
+      ].join("; ")
+    );
+    const output = result.output.toString("utf8").trim();
+    if (output.includes("__PI_LS_NOT_FOUND__")) {
+      throw new Error(`Path not found: ${inputPath}`);
+    }
+    if (output.includes("__PI_LS_NOT_DIR__")) {
+      throw new Error(`Not a directory: ${inputPath}`);
+    }
+    return output.split("\n").filter(Boolean).map((line) => line.replace(/[*=@|]$/, "")).sort(
+      (left, right) => left.toLowerCase().localeCompare(right.toLowerCase())
+    ).slice(0, limit);
+  };
+  const findFiles = async (pattern, inputPath = ".", limit = 1e3) => {
+    const remotePath = options.paths.toSandboxPath(inputPath);
+    const result = await runShell(
+      [
+        `if [ ! -e ${shellQuote(remotePath)} ]; then echo "__PI_FIND_NOT_FOUND__"; exit 2; fi`,
+        `if [ -d ${shellQuote(remotePath)} ]; then find ${shellQuote(remotePath)} -type f -print; else printf '%s\\n' ${shellQuote(remotePath)}; fi`
+      ].join("; ")
+    );
+    const output = result.output.toString("utf8").trim();
+    if (output.includes("__PI_FIND_NOT_FOUND__")) {
+      throw new Error(`Path not found: ${inputPath}`);
+    }
+    const searchRoot = remotePath;
+    return output.split("\n").filter(Boolean).map((absolutePath) => {
+      if (absolutePath === searchRoot) {
+        return path3.posix.basename(absolutePath);
+      }
+      return path3.posix.relative(searchRoot, absolutePath);
+    }).filter(
+      (candidate) => candidate.length > 0 && path3.matchesGlob(candidate, pattern)
+    ).sort(
+      (left, right) => left.toLowerCase().localeCompare(right.toLowerCase())
+    ).slice(0, limit);
+  };
+  const grepFiles = async (pattern, input) => {
+    const remotePath = options.paths.toSandboxPath(input.path ?? ".");
+    const relativeTarget = options.paths.toRelativePath(remotePath);
+    const flags = [
+      "-R",
+      "-n",
+      "--binary-files=without-match",
+      ...input.ignoreCase ? ["-i"] : [],
+      ...input.literal ? ["-F"] : [],
+      ...typeof input.context === "number" && input.context > 0 ? ["-C", String(input.context)] : [],
+      ...input.glob ? ["--include", input.glob] : []
+    ];
+    const limit = Math.max(1, input.limit ?? 100);
+    const result = await runShell(
+      [
+        `if [ ! -e ${shellQuote(remotePath)} ]; then echo "__PI_GREP_NOT_FOUND__"; exit 2; fi`,
+        `cd ${shellQuote(options.paths.sandboxWorkDir)}`,
+        `grep ${flags.map(shellQuote).join(" ")} -- ${shellQuote(pattern)} ${shellQuote(relativeTarget)} 2>/dev/null | head -n ${limit}`
+      ].join("; ")
+    );
+    const output = result.output.toString("utf8").trim();
+    if (output.includes("__PI_GREP_NOT_FOUND__")) {
+      throw new Error(`Path not found: ${input.path ?? "."}`);
+    }
+    return output || "No matches found";
+  };
+  return {
+    paths: options.paths,
+    readBuffer,
+    writeFile: writeFile3,
+    editFile,
+    listDirectory,
+    findFiles,
+    grepFiles,
+    async access(inputPath) {
+      await readBuffer(inputPath);
+    },
+    async exec(command, cwd, input) {
+      const controller = new AbortController();
+      const timeoutId = typeof input.timeout === "number" && input.timeout > 0 ? setTimeout(() => controller.abort(), input.timeout * 1e3) : void 0;
+      const forwardedSignal = input.signal;
+      const onAbort = () => controller.abort();
+      forwardedSignal?.addEventListener("abort", onAbort, { once: true });
+      try {
+        const result = await runShell(command, {
+          cwd,
+          signal: controller.signal,
+          onData: input.onData
+        });
+        return { exitCode: result.exitCode };
+      } finally {
+        forwardedSignal?.removeEventListener("abort", onAbort);
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+      }
+    }
+  };
+}
+
+// src/pi-skills.ts
+import path4 from "path";
+async function writePiSkills(args) {
+  for (const skill of args.skills) {
+    const name = safePiMetadataSegment(skill.name, "skill");
+    const remotePath = path4.posix.join(
+      args.sessionWorkDir,
+      ".pi",
+      "skills",
+      name,
+      "SKILL.md"
+    );
+    await args.sandbox.writeTextFile({
+      path: remotePath,
+      content: renderPiSkillFile(skill),
+      ...args.abortSignal ? { abortSignal: args.abortSignal } : {}
+    });
+  }
+}
+
+// src/pi-translate.ts
+import { randomBytes } from "crypto";
+function createPiTranslatorState(options = {}) {
+  const map = options.nativeToCommon instanceof Map ? options.nativeToCommon : new Map(Object.entries(options.nativeToCommon ?? {}));
+  return {
+    promptStarted: false,
+    streamedAssistantText: "",
+    currentTextId: void 0,
+    currentReasoningId: void 0,
+    reasoningStarted: false,
+    observedToolNames: /* @__PURE__ */ new Map(),
+    hostToolResults: /* @__PURE__ */ new Map(),
+    builtinToolNames: new Set(options.builtinToolNames ?? []),
+    nativeToCommonNameMap: map
+  };
+}
+function newId() {
+  return randomBytes(8).toString("hex");
+}
+function unwrapPiToolResult(event) {
+  const candidates = [];
+  const result = event.result;
+  if (result && typeof result === "object") {
+    const inner = result.content;
+    if (Array.isArray(inner)) candidates.push(inner);
+  }
+  if (Array.isArray(event.content)) candidates.push(event.content);
+  for (const content of candidates) {
+    if (!Array.isArray(content)) continue;
+    const text = content.filter(
+      (p) => !!p && typeof p === "object" && p.type === "text" && typeof p.text === "string"
+    ).map((p) => p.text).join("");
+    if (text) return text;
+  }
+  if (typeof event.result === "string") return event.result;
+  if (typeof event.content === "string") return event.content;
+  return event.result ?? event.content ?? null;
+}
+function resolveToolName(state, nativeName) {
+  const common = state.nativeToCommonNameMap.get(nativeName);
+  return { wire: common ?? nativeName, native: nativeName };
+}
+function translatePiEvent(event, state) {
+  switch (event.type) {
+    case "turn_start":
+    case "message_start": {
+      if (event.type === "message_start" && event.message?.role !== "assistant") {
+        return [];
+      }
+      state.promptStarted = true;
+      state.streamedAssistantText = "";
+      state.currentTextId = void 0;
+      state.currentReasoningId = void 0;
+      state.reasoningStarted = false;
+      return [];
+    }
+    case "message_update": {
+      if (!state.promptStarted) return [];
+      const update = event.assistantMessageEvent;
+      if (!update) return [];
+      if (update.type === "text_delta" && typeof update.delta === "string") {
+        const parts = [];
+        if (state.reasoningStarted && state.currentReasoningId) {
+          parts.push({
+            type: "reasoning-end",
+            id: state.currentReasoningId
+          });
+          state.reasoningStarted = false;
+          state.currentReasoningId = void 0;
+        }
+        if (!state.currentTextId) {
+          state.currentTextId = newId();
+          parts.push({ type: "text-start", id: state.currentTextId });
+        }
+        state.streamedAssistantText += update.delta;
+        parts.push({
+          type: "text-delta",
+          id: state.currentTextId,
+          delta: update.delta
+        });
+        return parts;
+      }
+      if (update.type === "thinking_delta" && typeof update.delta === "string") {
+        const parts = [];
+        if (state.currentTextId) {
+          parts.push({ type: "text-end", id: state.currentTextId });
+          state.currentTextId = void 0;
+        }
+        if (!state.currentReasoningId) {
+          state.currentReasoningId = newId();
+        }
+        if (!state.reasoningStarted) {
+          state.reasoningStarted = true;
+          parts.push({ type: "reasoning-start", id: state.currentReasoningId });
+        }
+        parts.push({
+          type: "reasoning-delta",
+          id: state.currentReasoningId,
+          delta: update.delta
+        });
+        return parts;
+      }
+      return [];
+    }
+    case "message_end":
+    case "turn_end": {
+      if (!state.promptStarted) return [];
+      const parts = [];
+      const fullText = extractAssistantText(event.message);
+      if (state.currentTextId && fullText.startsWith(state.streamedAssistantText) && fullText.length > state.streamedAssistantText.length) {
+        const missing = fullText.slice(state.streamedAssistantText.length);
+        state.streamedAssistantText = fullText;
+        parts.push({
+          type: "text-delta",
+          id: state.currentTextId,
+          delta: missing
+        });
+      }
+      if (state.currentTextId) {
+        parts.push({ type: "text-end", id: state.currentTextId });
+        state.currentTextId = void 0;
+      }
+      if (state.reasoningStarted && state.currentReasoningId) {
+        parts.push({ type: "reasoning-end", id: state.currentReasoningId });
+        state.reasoningStarted = false;
+        state.currentReasoningId = void 0;
+      }
+      return parts;
+    }
+    case "tool_execution_start": {
+      if (!event.toolCallId || !event.toolName) return [];
+      const { wire, native } = resolveToolName(state, event.toolName);
+      state.observedToolNames.set(event.toolCallId, wire);
+      const providerExecuted = state.builtinToolNames.has(native);
+      const input = serializeToolOutput(event.args ?? event.input ?? {});
+      return [
+        {
+          type: "tool-call",
+          toolCallId: event.toolCallId,
+          toolName: wire,
+          input,
+          ...wire !== native ? { nativeName: native } : {},
+          ...providerExecuted ? { providerExecuted: true } : {}
+        }
+      ];
+    }
+    case "tool_execution_end":
+    case "tool_result": {
+      if (!event.toolCallId) return [];
+      const recordedName = state.observedToolNames.get(event.toolCallId);
+      const nativeName = event.toolName;
+      const wire = recordedName ?? (nativeName ? resolveToolName(state, nativeName).wire : void 0);
+      if (!wire) return [];
+      const result = state.hostToolResults.has(event.toolCallId) ? state.hostToolResults.get(event.toolCallId) ?? null : unwrapPiToolResult(event);
+      state.hostToolResults.delete(event.toolCallId);
+      return [
+        {
+          type: "tool-result",
+          toolCallId: event.toolCallId,
+          toolName: wire,
+          result,
+          ...event.isError ? { isError: true } : {}
+        }
+      ];
+    }
+    case "compaction_end": {
+      if (event.aborted) return [];
+      const result = event.result;
+      if (!result || typeof result !== "object") return [];
+      const rawSummary = result.summary;
+      const summary = typeof rawSummary === "string" ? rawSummary : "(no summary provided)";
+      const tokensBefore = result.tokensBefore;
+      return [
+        {
+          type: "compaction",
+          trigger: event.reason === "manual" ? "manual" : "auto",
+          summary,
+          ...typeof tokensBefore === "number" ? { tokensBefore } : {}
+        }
+      ];
+    }
+    default:
+      return [];
+  }
+}
+
+// src/pi-typebox-adapter.ts
+import { Type } from "typebox";
+function toolSpecToTypeBoxParameters(jsonSchema) {
+  return Type.Unsafe(jsonSchema);
+}
+
+// src/pi-workspace-vfs.ts
+import fs from "fs";
+import { syncBuiltinESMExports } from "module";
+import path5 from "path";
+var mountedRoots = /* @__PURE__ */ new Map();
+var mutableFs = fs;
+var mutableFsPromises = fs.promises;
+var originalFsSyncMethods = {
+  existsSync: fs.existsSync,
+  mkdirSync: fs.mkdirSync,
+  openSync: fs.openSync,
+  readFileSync: fs.readFileSync,
+  readdirSync: fs.readdirSync,
+  realpathSync: fs.realpathSync,
+  renameSync: fs.renameSync,
+  rmSync: fs.rmSync,
+  statSync: fs.statSync,
+  writeFileSync: fs.writeFileSync
+};
+var originalFsCallbackMethods = {
+  mkdir: fs.mkdir,
+  realpath: fs.realpath,
+  rmdir: fs.rmdir,
+  stat: fs.stat,
+  utimes: fs.utimes,
+  writeFile: fs.writeFile
+};
+var originalFsPromises = {
+  mkdir: fs.promises.mkdir.bind(fs.promises),
+  readFile: fs.promises.readFile.bind(fs.promises),
+  writeFile: fs.promises.writeFile.bind(fs.promises)
+};
+function isInsidePath2(parent, candidate) {
+  const relative = path5.relative(parent, candidate);
+  return relative === "" || !relative.startsWith("..") && !path5.isAbsolute(relative);
+}
+function resolveAbsolutePath(inputPath) {
+  return path5.isAbsolute(inputPath) ? path5.normalize(inputPath) : path5.resolve(inputPath);
+}
+function findMountedRoot(inputPath) {
+  const resolvedPath = resolveAbsolutePath(inputPath);
+  let bestMatch;
+  for (const mountedRoot of mountedRoots.values()) {
+    if (!isInsidePath2(mountedRoot.mountPoint, resolvedPath)) {
+      continue;
+    }
+    if (!bestMatch || mountedRoot.mountPoint.length > bestMatch.mountPoint.length) {
+      bestMatch = mountedRoot;
+    }
+  }
+  return bestMatch;
+}
+function mapToBackingPath(inputPath) {
+  const mountedRoot = findMountedRoot(inputPath);
+  if (!mountedRoot) {
+    return null;
+  }
+  const resolvedPath = resolveAbsolutePath(inputPath);
+  const relativePath = path5.relative(mountedRoot.mountPoint, resolvedPath);
+  return relativePath ? path5.join(mountedRoot.backingRoot, relativePath) : mountedRoot.backingRoot;
+}
+function mapRealpathResult(inputPath, result) {
+  const mountedRoot = findMountedRoot(inputPath);
+  if (!mountedRoot) {
+    return result;
+  }
+  let normalizedBackingRoot = path5.resolve(mountedRoot.backingRoot);
+  try {
+    const realpath = originalFsSyncMethods.realpathSync.native ?? originalFsSyncMethods.realpathSync;
+    normalizedBackingRoot = path5.resolve(realpath(mountedRoot.backingRoot));
+  } catch {
+  }
+  const normalizedResult = path5.resolve(result);
+  if (!isInsidePath2(normalizedBackingRoot, normalizedResult)) {
+    return result;
+  }
+  const relativePath = path5.relative(normalizedBackingRoot, normalizedResult);
+  return relativePath ? path5.join(mountedRoot.mountPoint, relativePath) : mountedRoot.mountPoint;
+}
+function mapRenamePaths(sourcePath, destinationPath) {
+  const sourceRoot = findMountedRoot(sourcePath);
+  const destinationRoot = findMountedRoot(destinationPath);
+  if (!sourceRoot && !destinationRoot) {
+    return null;
+  }
+  if (!sourceRoot || !destinationRoot || sourceRoot.mountPoint !== destinationRoot.mountPoint) {
+    throw new Error(
+      "Pi logical VFS paths cannot rename across mount boundaries"
+    );
+  }
+  return [
+    mapToBackingPath(sourcePath) ?? sourcePath,
+    mapToBackingPath(destinationPath) ?? destinationPath
+  ];
+}
+function wrapSinglePathSync(original, options = {}) {
+  return ((...args) => {
+    const [inputPath] = args;
+    if (typeof inputPath === "string") {
+      const mappedPath = mapToBackingPath(inputPath);
+      if (mappedPath) {
+        const result = original(
+          ...[mappedPath, ...args.slice(1)]
+        );
+        return options.mapResult ? options.mapResult(inputPath, result) : result;
+      }
+    }
+    return original(...args);
+  });
+}
+function wrapRenameSync(original) {
+  return ((...args) => {
+    const [sourcePath, destinationPath] = args;
+    if (typeof sourcePath === "string" && typeof destinationPath === "string") {
+      const mappedPaths = mapRenamePaths(sourcePath, destinationPath);
+      if (mappedPaths) {
+        return original(
+          ...[
+            mappedPaths[0],
+            mappedPaths[1],
+            ...args.slice(2)
+          ]
+        );
+      }
+    }
+    return original(...args);
+  });
+}
+function wrapSinglePathCallback(original, options = {}) {
+  return ((...args) => {
+    const [inputPath] = args;
+    if (typeof inputPath === "string") {
+      const mappedPath = mapToBackingPath(inputPath);
+      if (mappedPath) {
+        const nextArgs = [mappedPath, ...args.slice(1)];
+        const maybeCallback = nextArgs.at(-1);
+        if (options.mapCallbackResult && typeof maybeCallback === "function") {
+          nextArgs[nextArgs.length - 1] = (error, result, ...rest) => {
+            const mappedResult = error ? result : options.mapCallbackResult?.(inputPath, result);
+            maybeCallback(
+              error,
+              mappedResult,
+              ...rest
+            );
+          };
+        }
+        return original(...nextArgs);
+      }
+    }
+    return original(...args);
+  });
+}
+function wrapSinglePathPromise(original) {
+  return (async (...args) => {
+    const [inputPath] = args;
+    if (typeof inputPath === "string") {
+      const mappedPath = mapToBackingPath(inputPath);
+      if (mappedPath) {
+        return await original(
+          ...[mappedPath, ...args.slice(1)]
+        );
+      }
+    }
+    return await original(...args);
+  });
+}
+function createWrappedRealpathSync() {
+  const wrapped = wrapSinglePathSync(originalFsSyncMethods.realpathSync, {
+    mapResult: (inputPath, result) => typeof result === "string" ? mapRealpathResult(inputPath, result) : result
+  });
+  if (originalFsSyncMethods.realpathSync.native) {
+    wrapped.native = wrapSinglePathSync(
+      originalFsSyncMethods.realpathSync.native,
+      {
+        mapResult: (inputPath, result) => typeof result === "string" ? mapRealpathResult(inputPath, result) : result
+      }
+    );
+  }
+  return wrapped;
+}
+var wrappedFsSyncMethods = {
+  existsSync: wrapSinglePathSync(originalFsSyncMethods.existsSync),
+  mkdirSync: wrapSinglePathSync(originalFsSyncMethods.mkdirSync),
+  openSync: wrapSinglePathSync(originalFsSyncMethods.openSync),
+  readFileSync: wrapSinglePathSync(originalFsSyncMethods.readFileSync),
+  readdirSync: wrapSinglePathSync(originalFsSyncMethods.readdirSync),
+  realpathSync: createWrappedRealpathSync(),
+  renameSync: wrapRenameSync(originalFsSyncMethods.renameSync),
+  rmSync: wrapSinglePathSync(originalFsSyncMethods.rmSync),
+  statSync: wrapSinglePathSync(originalFsSyncMethods.statSync),
+  writeFileSync: wrapSinglePathSync(originalFsSyncMethods.writeFileSync)
+};
+var wrappedFsCallbackMethods = {
+  mkdir: wrapSinglePathCallback(originalFsCallbackMethods.mkdir),
+  realpath: wrapSinglePathCallback(originalFsCallbackMethods.realpath, {
+    mapCallbackResult: (inputPath, result) => typeof result === "string" ? mapRealpathResult(inputPath, result) : result
+  }),
+  rmdir: wrapSinglePathCallback(originalFsCallbackMethods.rmdir),
+  stat: wrapSinglePathCallback(originalFsCallbackMethods.stat),
+  utimes: wrapSinglePathCallback(originalFsCallbackMethods.utimes),
+  writeFile: wrapSinglePathCallback(originalFsCallbackMethods.writeFile)
+};
+var wrappedFsPromises = {
+  mkdir: wrapSinglePathPromise(originalFsPromises.mkdir),
+  readFile: wrapSinglePathPromise(originalFsPromises.readFile),
+  writeFile: wrapSinglePathPromise(originalFsPromises.writeFile)
+};
+function areExtraFsPatchesInstalled() {
+  return mutableFs.existsSync === wrappedFsSyncMethods.existsSync;
+}
+function installExtraFsPatches() {
+  if (areExtraFsPatchesInstalled()) return;
+  mutableFs.existsSync = wrappedFsSyncMethods.existsSync;
+  mutableFs.mkdirSync = wrappedFsSyncMethods.mkdirSync;
+  mutableFs.openSync = wrappedFsSyncMethods.openSync;
+  mutableFs.readFileSync = wrappedFsSyncMethods.readFileSync;
+  mutableFs.readdirSync = wrappedFsSyncMethods.readdirSync;
+  mutableFs.realpathSync = wrappedFsSyncMethods.realpathSync;
+  mutableFs.renameSync = wrappedFsSyncMethods.renameSync;
+  mutableFs.rmSync = wrappedFsSyncMethods.rmSync;
+  mutableFs.statSync = wrappedFsSyncMethods.statSync;
+  mutableFs.writeFileSync = wrappedFsSyncMethods.writeFileSync;
+  mutableFs.mkdir = wrappedFsCallbackMethods.mkdir;
+  mutableFs.realpath = wrappedFsCallbackMethods.realpath;
+  mutableFs.rmdir = wrappedFsCallbackMethods.rmdir;
+  mutableFs.stat = wrappedFsCallbackMethods.stat;
+  mutableFs.utimes = wrappedFsCallbackMethods.utimes;
+  mutableFs.writeFile = wrappedFsCallbackMethods.writeFile;
+  mutableFsPromises.mkdir = wrappedFsPromises.mkdir;
+  mutableFsPromises.readFile = wrappedFsPromises.readFile;
+  mutableFsPromises.writeFile = wrappedFsPromises.writeFile;
+  syncBuiltinESMExports();
+}
+function restoreExtraFsPatches() {
+  if (!areExtraFsPatchesInstalled()) return;
+  mutableFs.existsSync = originalFsSyncMethods.existsSync;
+  mutableFs.mkdirSync = originalFsSyncMethods.mkdirSync;
+  mutableFs.openSync = originalFsSyncMethods.openSync;
+  mutableFs.readFileSync = originalFsSyncMethods.readFileSync;
+  mutableFs.readdirSync = originalFsSyncMethods.readdirSync;
+  mutableFs.realpathSync = originalFsSyncMethods.realpathSync;
+  mutableFs.renameSync = originalFsSyncMethods.renameSync;
+  mutableFs.rmSync = originalFsSyncMethods.rmSync;
+  mutableFs.statSync = originalFsSyncMethods.statSync;
+  mutableFs.writeFileSync = originalFsSyncMethods.writeFileSync;
+  mutableFs.mkdir = originalFsCallbackMethods.mkdir;
+  mutableFs.realpath = originalFsCallbackMethods.realpath;
+  mutableFs.rmdir = originalFsCallbackMethods.rmdir;
+  mutableFs.stat = originalFsCallbackMethods.stat;
+  mutableFs.utimes = originalFsCallbackMethods.utimes;
+  mutableFs.writeFile = originalFsCallbackMethods.writeFile;
+  mutableFsPromises.mkdir = originalFsPromises.mkdir;
+  mutableFsPromises.readFile = originalFsPromises.readFile;
+  mutableFsPromises.writeFile = originalFsPromises.writeFile;
+  syncBuiltinESMExports();
+}
+var PiWorkspaceVfs = class {
+  constructor() {
+    this.backingRoot = null;
+    this.mountPoint = null;
+  }
+  disposeMount() {
+    if (this.mountPoint) {
+      mountedRoots.delete(this.mountPoint);
+    }
+    this.backingRoot = null;
+    this.mountPoint = null;
+  }
+  mount(backingRoot, mountPoint) {
+    if (this.backingRoot === backingRoot && this.mountPoint === mountPoint) {
+      return;
+    }
+    const resolvedBackingRoot = path5.resolve(backingRoot);
+    const resolvedMountPoint = path5.resolve(mountPoint);
+    if (this.mountPoint) {
+      this.disposeMount();
+    }
+    mountedRoots.set(resolvedMountPoint, {
+      backingRoot: resolvedBackingRoot,
+      mountPoint: resolvedMountPoint
+    });
+    installExtraFsPatches();
+    this.backingRoot = resolvedBackingRoot;
+    this.mountPoint = resolvedMountPoint;
+  }
+  unmount() {
+    this.disposeMount();
+    if (mountedRoots.size === 0) {
+      restoreExtraFsPatches();
+    }
+  }
+};
+
+// src/pi-workspace-mirror.ts
+import {
+  mkdir as mkdir2,
+  readFile as readFile2,
+  readdir,
+  rm,
+  stat,
+  writeFile as writeFile2
+} from "fs/promises";
+import path6 from "path";
+var PI_CONFIG_DIRS = [".pi", ".agents"];
+var PI_CONTEXT_FILENAMES = ["AGENTS.md", "AGENTS.MD"];
+function normalizeRelativePath(inputPath) {
+  const normalized = inputPath.split(path6.posix.sep).join(path6.sep);
+  const relative = path6.normalize(normalized);
+  if (relative === "" || relative === "." || path6.isAbsolute(relative) || relative === ".." || relative.startsWith(`..${path6.sep}`)) {
+    throw new Error(
+      `Sandbox workspace mirror received an invalid relative path: ${inputPath}`
+    );
+  }
+  return relative;
+}
+async function readCommandOutput(sandbox, command) {
+  const result = await sandbox.run({ command });
+  const output = result.stdout || result.stderr;
+  if (result.exitCode != null && result.exitCode !== 0) {
+    throw new Error(
+      output || `Sandbox command failed with exit code ${result.exitCode}`
+    );
+  }
+  return output;
+}
+async function listRemoteWorkspaceEntries(sandbox, sandboxWorkDir) {
+  const contextPredicate = PI_CONTEXT_FILENAMES.map(
+    (name) => `-name ${shellQuote(name)}`
+  ).join(" -o ");
+  const configFinds = PI_CONFIG_DIRS.map(
+    (dir) => `  if [ -d ./${dir} ]; then find -L ./${dir} \\( -type d -o -type f \\) -print0; fi;`
+  );
+  const listCommand = [
+    "{",
+    ...configFinds,
+    `  find . -maxdepth 1 -type f \\( ${contextPredicate} \\) -print0;`,
+    "} |",
+    "while IFS= read -r -d '' entry; do",
+    "  rel=${entry#./}",
+    '  if [ -d "$entry" ]; then',
+    `    printf 'd\\t%s\\n' "$rel"`,
+    '  elif [ -f "$entry" ]; then',
+    `    printf 'f\\t%s\\n' "$rel"`,
+    "  fi",
+    "done | LC_ALL=C sort"
+  ].join("\n");
+  const output = await readCommandOutput(
+    sandbox,
+    [`cd ${shellQuote(sandboxWorkDir)}`, listCommand].join(" && ")
+  );
+  const directories = [];
+  const files = [];
+  for (const line of output.split("\n").filter(Boolean)) {
+    const [kind, rawPath] = line.split("	", 2);
+    if (!rawPath) continue;
+    const relativePath = normalizeRelativePath(rawPath);
+    if (kind === "d") directories.push(relativePath);
+    else if (kind === "f") files.push(relativePath);
+  }
+  return { directories, files };
+}
+async function pathKind(target) {
+  try {
+    const stats = await stat(target);
+    if (stats.isDirectory()) return "directory";
+    if (stats.isFile()) return "file";
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function collectHostSubtree(rootDir, currentDir, directories, files) {
+  const entries = await readdir(currentDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isSymbolicLink()) continue;
+    const absolutePath = path6.join(currentDir, entry.name);
+    const relativePath = path6.relative(rootDir, absolutePath);
+    if (entry.isDirectory()) {
+      directories.push(relativePath);
+      await collectHostSubtree(rootDir, absolutePath, directories, files);
+    } else if (entry.isFile()) {
+      files.push(relativePath);
+    }
+  }
+}
+async function collectHostScopedEntries(rootDir) {
+  const directories = [];
+  const files = [];
+  for (const dir of PI_CONFIG_DIRS) {
+    const configDir = path6.join(rootDir, dir);
+    if (await pathKind(configDir) === "directory") {
+      directories.push(dir);
+      await collectHostSubtree(rootDir, configDir, directories, files);
+    }
+  }
+  for (const name of PI_CONTEXT_FILENAMES) {
+    if (await pathKind(path6.join(rootDir, name)) === "file") {
+      files.push(name);
+    }
+  }
+  return { directories, files };
+}
+function buildRequiredDirectories(remoteDirectories, remoteFiles) {
+  const directories = /* @__PURE__ */ new Set();
+  for (const directory of remoteDirectories) {
+    directories.add(normalizeRelativePath(directory));
+  }
+  for (const file of remoteFiles) {
+    let current = path6.dirname(normalizeRelativePath(file));
+    while (current !== "." && current !== path6.sep && current.length > 0) {
+      directories.add(current);
+      current = path6.dirname(current);
+    }
+  }
+  return directories;
+}
+async function syncHostWorkspaceFromSandbox(args) {
+  const { sandbox, sandboxWorkDir, hostWorkDir } = args;
+  const remoteEntries = await listRemoteWorkspaceEntries(
+    sandbox,
+    sandboxWorkDir
+  );
+  const hostEntries = await collectHostScopedEntries(hostWorkDir);
+  const remoteFiles = new Set(remoteEntries.files);
+  const requiredDirectories = buildRequiredDirectories(
+    remoteEntries.directories,
+    remoteEntries.files
+  );
+  for (const relativePath of hostEntries.files) {
+    if (!remoteFiles.has(relativePath)) {
+      await rm(path6.join(hostWorkDir, relativePath), { force: true });
+    }
+  }
+  const removableDirectories = [...hostEntries.directories].filter((p) => !requiredDirectories.has(p)).sort((a, b) => b.length - a.length);
+  for (const relativePath of removableDirectories) {
+    await rm(path6.join(hostWorkDir, relativePath), {
+      recursive: true,
+      force: true
+    });
+  }
+  for (const relativePath of [...requiredDirectories].sort(
+    (a, b) => a.length - b.length
+  )) {
+    await mkdir2(path6.join(hostWorkDir, relativePath), { recursive: true });
+  }
+  for (const relativePath of remoteEntries.files) {
+    const remotePath = path6.posix.join(
+      sandboxWorkDir,
+      relativePath.split(path6.sep).join("/")
+    );
+    const bytes = await sandbox.readBinaryFile({ path: remotePath });
+    if (!bytes) {
+      throw new Error(
+        `Sandbox workspace file disappeared during mirror sync: ${remotePath}`
+      );
+    }
+    const content = Buffer.from(bytes);
+    const hostPath = path6.join(hostWorkDir, relativePath);
+    let shouldWrite = true;
+    try {
+      const existing = await readFile2(hostPath);
+      shouldWrite = !existing.equals(content);
+    } catch {
+      shouldWrite = true;
+    }
+    if (shouldWrite) {
+      await mkdir2(path6.dirname(hostPath), { recursive: true });
+      await writeFile2(hostPath, content);
+    }
+  }
+}
+
+// src/pi-session.ts
+var HARNESS_ID2 = "pi";
+var parkedPiSessions = /* @__PURE__ */ new Map();
+function isWithinWorkspace(candidate, sessionWorkDir, hostWorkDir) {
+  const inside = (parent, child) => {
+    const rel = path7.relative(parent, child);
+    return rel === "" || !rel.startsWith("..") && !path7.isAbsolute(rel);
+  };
+  return inside(sessionWorkDir, candidate) || inside(hostWorkDir, candidate);
+}
+var PI_NATIVE_BUILTIN_NAMES = [
+  "read",
+  "write",
+  "edit",
+  "bash",
+  "grep",
+  "find",
+  "ls"
+];
+var NATIVE_TO_COMMON = {
+  find: "glob"
+};
+var PI_NATIVE_TOOL_KINDS = {
+  read: "readonly",
+  write: "edit",
+  edit: "edit",
+  bash: "bash",
+  grep: "readonly",
+  find: "readonly",
+  ls: "readonly"
+};
+async function createPiSession(input) {
+  if (input.isResume) {
+    const parkedSession = parkedPiSessions.get(input.sessionId);
+    if (parkedSession) {
+      parkedPiSessions.delete(input.sessionId);
+      return {
+        ...parkedSession,
+        isResume: true
+      };
+    }
+  }
+  const safeSessionId = input.sessionId.replace(/[\\/: ]/g, "-");
+  const hostRoot = path7.join(tmpdir(), "ai-sdk-harness", "pi", safeSessionId);
+  const hostWorkDir = path7.join(hostRoot, "workspace");
+  const hostAgentDir = path7.join(hostRoot, "agent");
+  const hostSessionDir = path7.join(hostRoot, "sessions");
+  const sessionWorkDir = input.sessionWorkDir;
+  await mkdir3(hostWorkDir, { recursive: true });
+  await mkdir3(hostAgentDir, { recursive: true });
+  await mkdir3(hostSessionDir, { recursive: true });
+  const sandbox = input.sandboxSession.restricted();
+  const permissionMode = input.permissionMode ?? "allow-all";
+  if (input.skills.length > 0) {
+    await writePiSkills({
+      sandbox,
+      sessionWorkDir: input.sessionWorkDir,
+      skills: input.skills,
+      ...input.abortSignal ? { abortSignal: input.abortSignal } : {}
+    });
+  }
+  let resumeSessionFilePath;
+  if (input.isResume && input.resumeSessionFileName) {
+    resumeSessionFilePath = await pullSessionFileFromSandbox({
+      sandbox,
+      sessionWorkDir: input.sessionWorkDir,
+      hostSessionDir,
+      sessionFileName: input.resumeSessionFileName,
+      ...input.abortSignal ? { abortSignal: input.abortSignal } : {}
+    });
+  }
+  await syncHostWorkspaceFromSandbox({
+    sandbox,
+    sandboxWorkDir: input.sessionWorkDir,
+    hostWorkDir
+  });
+  const workspaceVfs = new PiWorkspaceVfs();
+  workspaceVfs.mount(hostWorkDir, sessionWorkDir);
+  const paths = createPiPathMapper(hostWorkDir, sessionWorkDir);
+  const authStorage = AuthStorage.create(path7.join(hostAgentDir, "auth.json"));
+  const modelRegistry = ModelRegistry.create(
+    authStorage,
+    path7.join(hostAgentDir, "models.json")
+  );
+  const settingsManager = SettingsManager.inMemory();
+  const resolverEnv = resolvePiAuth(input.settings.auth, process.env, {
+    authStorage,
+    modelRegistry
+  });
+  const resolveModel = createPiModelResolver(modelRegistry, resolverEnv);
+  const resolvedModel = resolveModel(input.settings.model);
+  const resourceLoader = new DefaultResourceLoader({
+    cwd: sessionWorkDir,
+    agentDir: hostAgentDir,
+    settingsManager,
+    appendSystemPromptOverride: () => [],
+    extensionFactories: [],
+    // Pi runs in the host process, so its default resource discovery reaches
+    // the host developer's personal config (`~/.pi/agent/*`, `~/.agents/*`).
+    // The harness does not expose extensions, themes, or prompt templates, so
+    // disable those entirely — this also avoids loading and executing a host
+    // developer's personal Pi extensions inside the server process. Skills are
+    // kept (the harness writes project skills into `.pi/skills`) but filtered
+    // to the workspace so host-home skills never reach the model.
+    noExtensions: true,
+    noThemes: true,
+    noPromptTemplates: true,
+    skillsOverride: (base) => ({
+      ...base,
+      skills: base.skills.filter(
+        (skill) => isWithinWorkspace(skill.filePath, sessionWorkDir, hostWorkDir)
+      )
+    })
+  });
+  await resourceLoader.reload();
+  let piSession;
+  let unsubscribe;
+  let lastToolsSignature;
+  let sessionFileName;
+  let stopped = false;
+  let suspending = false;
+  let instructionsApplied = input.isResume;
+  const pendingToolResults = /* @__PURE__ */ new Map();
+  const pendingToolApprovals = /* @__PURE__ */ new Map();
+  let currentEmit;
+  let translatorState;
+  let activeTurn;
+  const pendingCompactionParts = [];
+  const remoteOps = createPiRemoteOps({
+    sandbox,
+    paths,
+    onFileChange: (event, relPath) => {
+      currentEmit?.({ type: "file-change", event, path: relPath });
+    }
+  });
+  function settlePendingToolResults(reason) {
+    for (const pending of pendingToolResults.values()) {
+      pending.resolve({ error: reason });
+    }
+    pendingToolResults.clear();
+  }
+  function settlePendingToolApprovals(reason) {
+    for (const pending of pendingToolApprovals.values()) {
+      pending.resolve({ approved: false, reason });
+    }
+    pendingToolApprovals.clear();
+  }
+  async function persistSessionFile() {
+    if (!sessionFileName) return;
+    await persistSessionFileToSandbox({
+      sandbox,
+      sessionWorkDir: input.sessionWorkDir,
+      hostSessionDir,
+      sessionFileName
+    });
+  }
+  function createPromptControl(input2) {
+    const abortHandler = () => {
+      piSession?.abort().catch(() => {
+      });
+    };
+    if (input2.abortSignal) {
+      input2.abortSignal.addEventListener("abort", abortHandler, {
+        once: true
+      });
+      void input2.done.then(
+        () => {
+          input2.abortSignal?.removeEventListener("abort", abortHandler);
+        },
+        () => {
+          input2.abortSignal?.removeEventListener("abort", abortHandler);
+        }
+      );
+    }
+    return {
+      async submitToolResult(args) {
+        const pending = pendingToolResults.get(args.toolCallId);
+        if (!pending) return;
+        pendingToolResults.delete(args.toolCallId);
+        translatorState?.hostToolResults.set(args.toolCallId, args.output);
+        pending.resolve(args.output);
+      },
+      async submitToolApproval(args) {
+        const pending = pendingToolApprovals.get(args.approvalId);
+        if (!pending) return;
+        pendingToolApprovals.delete(args.approvalId);
+        pending.resolve({
+          approved: args.approved,
+          reason: args.reason
+        });
+      },
+      async submitUserMessage(text) {
+        await piSession?.steer(text);
+      },
+      done: input2.done
+    };
+  }
+  async function requestBuiltinToolApproval(args) {
+    if (!piBuiltinToolRequiresApproval({
+      permissionMode,
+      kind: PI_NATIVE_TOOL_KINDS[args.nativeName]
+    })) {
+      return { approved: true };
+    }
+    currentEmit?.({
+      type: "tool-approval-request",
+      approvalId: args.toolCallId,
+      toolCallId: args.toolCallId
+    });
+    return new Promise((resolve) => {
+      pendingToolApprovals.set(args.toolCallId, { resolve });
+    });
+  }
+  function buildToolDefinitions(userTools) {
+    const customTools = [
+      ...PI_NATIVE_BUILTIN_NAMES.map(
+        (native) => buildBuiltinToolDefinition({
+          native,
+          remoteOps,
+          requestApproval: requestBuiltinToolApproval
+        })
+      ),
+      ...userTools.map(
+        (spec) => buildUserToolDefinition(spec, pendingToolResults)
+      )
+    ];
+    return {
+      customTools,
+      builtinNames: [...PI_NATIVE_BUILTIN_NAMES]
+    };
+  }
+  async function rebuildPiSession(userTools, isFirstBuild) {
+    if (piSession) {
+      unsubscribe?.();
+      unsubscribe = void 0;
+      piSession.dispose();
+      piSession = void 0;
+      await new Promise((resolve) => setTimeout(resolve, 25));
+    }
+    const { customTools, builtinNames } = buildToolDefinitions(userTools);
+    const toolNames = customTools.map((t) => t.name);
+    const sessionManager = isFirstBuild && resumeSessionFilePath ? SessionManager.open(
+      resumeSessionFilePath,
+      hostSessionDir,
+      sessionWorkDir
+    ) : SessionManager.create(sessionWorkDir, hostSessionDir);
+    const { session } = await createAgentSession({
+      cwd: sessionWorkDir,
+      agentDir: hostAgentDir,
+      authStorage,
+      modelRegistry,
+      sessionManager,
+      settingsManager,
+      resourceLoader,
+      customTools,
+      tools: toolNames,
+      ...input.settings.thinkingLevel ? { thinkingLevel: input.settings.thinkingLevel } : {},
+      ...resolvedModel ? { model: resolvedModel } : {}
+    });
+    piSession = session;
+    const candidatePath = sessionManager.getSessionFile();
+    if (candidatePath) {
+      sessionFileName = path7.basename(candidatePath);
+    }
+    translatorState = createPiTranslatorState({
+      builtinToolNames: builtinNames,
+      nativeToCommon: NATIVE_TO_COMMON
+    });
+    unsubscribe = piSession.subscribe((rawEvent) => {
+      if (!translatorState) return;
+      const event = parseNativeEvent(rawEvent);
+      if (!event) return;
+      for (const part of translatePiEvent(event, translatorState)) {
+        if (currentEmit) {
+          currentEmit(part);
+        } else if (part.type === "compaction") {
+          pendingCompactionParts.push(part);
+        }
+      }
+    });
+  }
+  async function runTurn(turnOpts) {
+    if (stopped) {
+      throw new Error("Pi session has been stopped.");
+    }
+    const userTools = turnOpts.tools;
+    const signature = JSON.stringify(userTools.map((t) => t.name).sort());
+    const needsRebuild = piSession == null || signature !== lastToolsSignature;
+    if (needsRebuild) {
+      await rebuildPiSession(userTools, piSession == null);
+      lastToolsSignature = signature;
+    }
+    await resourceLoader.reload();
+    await syncHostWorkspaceFromSandbox({
+      sandbox,
+      sandboxWorkDir: input.sessionWorkDir,
+      hostWorkDir
+    });
+    currentEmit = turnOpts.emit;
+    translatorState = createPiTranslatorState({
+      builtinToolNames: [...PI_NATIVE_BUILTIN_NAMES],
+      nativeToCommon: NATIVE_TO_COMMON
+    });
+    turnOpts.emit({ type: "stream-start" });
+    const turnPromise = (async () => {
+      let terminalError;
+      const session = piSession;
+      const unsubErr = session.subscribe((raw) => {
+        const ev = parseNativeEvent(raw);
+        if (!ev) return;
+        const err = getPiTerminalError(ev);
+        if (err && !terminalError) {
+          terminalError = err;
+        }
+      });
+      try {
+        await session.prompt(turnOpts.text);
+        if (terminalError) {
+          if (suspending && isAbortError(terminalError)) return;
+          currentEmit?.({ type: "error", error: new Error(terminalError) });
+          return;
+        }
+        const stats = session.getSessionStats();
+        const finishReason = {
+          unified: "stop",
+          raw: void 0
+        };
+        const usage = {
+          inputTokens: {
+            total: stats.tokens.input,
+            noCache: void 0,
+            cacheRead: stats.tokens.cacheRead,
+            cacheWrite: stats.tokens.cacheWrite
+          },
+          outputTokens: {
+            total: stats.tokens.output,
+            text: void 0,
+            reasoning: void 0
+          }
+        };
+        currentEmit?.({ type: "finish-step", finishReason, usage });
+        currentEmit?.({
+          type: "finish",
+          finishReason,
+          totalUsage: usage
+        });
+      } catch (err) {
+        if (suspending && isAbortError(err)) return;
+        currentEmit?.({ type: "error", error: err });
+      } finally {
+        unsubErr();
+      }
+    })();
+    const activeTurnToken = {};
+    const done = turnPromise.finally(() => {
+      if (activeTurn?.token === activeTurnToken) {
+        activeTurn = void 0;
+      }
+      currentEmit = void 0;
+    });
+    activeTurn = {
+      token: activeTurnToken,
+      done
+    };
+    return createPromptControl({
+      done,
+      abortSignal: turnOpts.abortSignal
+    });
+  }
+  const doStop = async () => {
+    if (stopped) {
+      throw new Error("Pi session has been stopped.");
+    }
+    stopped = true;
+    parkedPiSessions.delete(input.sessionId);
+    settlePendingToolResults("Pi session stopped");
+    settlePendingToolApprovals("Pi session stopped");
+    if (sessionFileName) {
+      try {
+        await persistSessionFile();
+      } catch {
+      }
+    }
+    unsubscribe?.();
+    unsubscribe = void 0;
+    piSession?.dispose();
+    piSession = void 0;
+    workspaceVfs.unmount();
+    await rm2(hostRoot, { recursive: true, force: true });
+    return {
+      type: "resume-session",
+      harnessId: HARNESS_ID2,
+      specificationVersion: "harness-v1",
+      data: sessionFileName ? { sessionFileName } : {}
+    };
+  };
+  const sessionImpl = {
+    sessionId: input.sessionId,
+    isResume: input.isResume,
+    // The model Pi actually resolves to (the configured id, or its default when
+    // unset) — `gen_ai.request.model`.
+    ...resolvedModel?.id ? { modelId: resolvedModel.id } : {},
+    // Pi has no bridge to attach to and no on-disk event log to replay; its
+    // only resume path is restoring the session file on a fresh/snapshotted
+    // sandbox, i.e. `rerun`.
+    doPromptTurn: async (promptOpts) => {
+      let text = extractUserText(promptOpts.prompt);
+      if (!instructionsApplied && promptOpts.instructions) {
+        text = frameInstructions(promptOpts.instructions, text);
+      }
+      instructionsApplied = true;
+      return runTurn({
+        text,
+        tools: promptOpts.tools ?? [],
+        emit: promptOpts.emit,
+        abortSignal: promptOpts.abortSignal
+      });
+    },
+    doContinueTurn: async (continueOpts) => {
+      if (activeTurn != null) {
+        currentEmit = continueOpts.emit;
+        return createPromptControl({
+          done: activeTurn.done,
+          abortSignal: continueOpts.abortSignal
+        });
+      }
+      return runTurn({
+        text: "",
+        tools: continueOpts.tools ?? [],
+        emit: continueOpts.emit,
+        abortSignal: continueOpts.abortSignal
+      });
+    },
+    doCompact: async (customInstructions) => {
+      if (stopped) {
+        throw new Error("Pi session has been stopped.");
+      }
+      await piSession?.compact(customInstructions);
+    },
+    doDestroy: async () => {
+      if (stopped) return;
+      stopped = true;
+      parkedPiSessions.delete(input.sessionId);
+      settlePendingToolResults("Pi session stopped");
+      settlePendingToolApprovals("Pi session stopped");
+      unsubscribe?.();
+      unsubscribe = void 0;
+      piSession?.dispose();
+      piSession = void 0;
+      workspaceVfs.unmount();
+      await rm2(hostRoot, { recursive: true, force: true });
+    },
+    doStop,
+    doDetach: async () => {
+      if (activeTurn != null || pendingToolResults.size > 0) {
+        parkedPiSessions.set(input.sessionId, sessionImpl);
+        if (sessionFileName) {
+          try {
+            await persistSessionFile();
+          } catch {
+          }
+        }
+        return {
+          type: "resume-session",
+          harnessId: HARNESS_ID2,
+          specificationVersion: "harness-v1",
+          data: sessionFileName ? { sessionFileName } : {}
+        };
+      }
+      return doStop();
+    },
+    doSuspendTurn: async () => {
+      if (stopped) {
+        throw new Error("Pi session has been stopped.");
+      }
+      suspending = true;
+      await Promise.resolve(piSession?.abort()).catch(() => {
+      });
+      if (sessionFileName) {
+        try {
+          await persistSessionFile();
+        } catch {
+        }
+      }
+      stopped = true;
+      parkedPiSessions.delete(input.sessionId);
+      settlePendingToolResults("Pi session suspended");
+      settlePendingToolApprovals("Pi session suspended");
+      unsubscribe?.();
+      unsubscribe = void 0;
+      piSession?.dispose();
+      piSession = void 0;
+      workspaceVfs.unmount();
+      await rm2(hostRoot, { recursive: true, force: true });
+      return {
+        type: "continue-turn",
+        harnessId: HARNESS_ID2,
+        specificationVersion: "harness-v1",
+        data: sessionFileName ? { sessionFileName } : {}
+      };
+    }
+  };
+  return sessionImpl;
+}
+function isAbortError(value) {
+  if (value == null) return false;
+  if (typeof value === "object" && value.name === "AbortError") {
+    return true;
+  }
+  const text = typeof value === "string" ? value : value instanceof Error ? value.message : String(value);
+  return /\baborted\b|AbortError|operation was aborted/i.test(text);
+}
+function asPiToolResult(text) {
+  return {
+    content: [{ type: "text", text }],
+    details: void 0
+  };
+}
+async function maybeDenyPiBuiltinTool(input) {
+  const decision = await input.requestApproval({
+    toolCallId: input.toolCallId,
+    nativeName: input.nativeName
+  });
+  if (decision.approved) return void 0;
+  return asPiToolResult(
+    serializeToolOutput({
+      type: "execution-denied",
+      reason: decision.reason
+    })
+  );
+}
+function piBuiltinToolRequiresApproval(input) {
+  if (input.permissionMode === "allow-all") return false;
+  if (input.permissionMode === "allow-edits") return input.kind === "bash";
+  return input.kind === "edit" || input.kind === "bash";
+}
+function buildBuiltinToolDefinition(input) {
+  switch (input.native) {
+    case "read":
+      return defineTool({
+        name: "read",
+        label: "read",
+        description: "Read file contents.",
+        parameters: Type2.Object({ file_path: Type2.String() }),
+        async execute(toolCallId, params) {
+          const denied = await maybeDenyPiBuiltinTool({
+            toolCallId,
+            nativeName: "read",
+            requestApproval: input.requestApproval
+          });
+          if (denied) return denied;
+          const buf = await input.remoteOps.readBuffer(params.file_path);
+          return asPiToolResult(buf.toString("utf8"));
+        }
+      });
+    case "write":
+      return defineTool({
+        name: "write",
+        label: "write",
+        description: "Write content to a file.",
+        parameters: Type2.Object({
+          file_path: Type2.String(),
+          content: Type2.String()
+        }),
+        async execute(toolCallId, params) {
+          const denied = await maybeDenyPiBuiltinTool({
+            toolCallId,
+            nativeName: "write",
+            requestApproval: input.requestApproval
+          });
+          if (denied) return denied;
+          await input.remoteOps.writeFile(params.file_path, params.content);
+          return asPiToolResult(`Wrote ${params.file_path}`);
+        }
+      });
+    case "edit":
+      return defineTool({
+        name: "edit",
+        label: "edit",
+        description: "Edit a file by exact-string replacement.",
+        parameters: Type2.Object({
+          file_path: Type2.String(),
+          old_string: Type2.String(),
+          new_string: Type2.String()
+        }),
+        async execute(toolCallId, params) {
+          const denied = await maybeDenyPiBuiltinTool({
+            toolCallId,
+            nativeName: "edit",
+            requestApproval: input.requestApproval
+          });
+          if (denied) return denied;
+          await input.remoteOps.editFile(
+            params.file_path,
+            params.old_string,
+            params.new_string
+          );
+          return asPiToolResult(`Edited ${params.file_path}`);
+        }
+      });
+    case "bash":
+      return defineTool({
+        name: "bash",
+        label: "bash",
+        description: "Execute a shell command.",
+        parameters: Type2.Object({
+          command: Type2.String(),
+          timeout: Type2.Optional(
+            Type2.Number({ description: "Timeout in seconds." })
+          )
+        }),
+        async execute(toolCallId, params, signal) {
+          const denied = await maybeDenyPiBuiltinTool({
+            toolCallId,
+            nativeName: "bash",
+            requestApproval: input.requestApproval
+          });
+          if (denied) return denied;
+          const chunks = [];
+          const result = await input.remoteOps.exec(params.command, ".", {
+            onData(data) {
+              chunks.push(data);
+            },
+            ...signal ? { signal } : {},
+            ...typeof params.timeout === "number" ? { timeout: params.timeout } : {}
+          });
+          const out = Buffer.concat(chunks).toString("utf8");
+          const text = `${out}${result.exitCode != null ? `
+
+(exit ${result.exitCode})` : ""}`.trim();
+          return asPiToolResult(text);
+        }
+      });
+    case "grep":
+      return defineTool({
+        name: "grep",
+        label: "grep",
+        description: "Search file contents with regex.",
+        parameters: Type2.Object({
+          pattern: Type2.String(),
+          path: Type2.Optional(Type2.String()),
+          glob: Type2.Optional(Type2.String()),
+          ignoreCase: Type2.Optional(Type2.Boolean()),
+          literal: Type2.Optional(Type2.Boolean()),
+          context: Type2.Optional(Type2.Number()),
+          limit: Type2.Optional(Type2.Number())
+        }),
+        async execute(toolCallId, params) {
+          const denied = await maybeDenyPiBuiltinTool({
+            toolCallId,
+            nativeName: "grep",
+            requestApproval: input.requestApproval
+          });
+          if (denied) return denied;
+          const out = await input.remoteOps.grepFiles(params.pattern, params);
+          return asPiToolResult(out);
+        }
+      });
+    case "find":
+      return defineTool({
+        name: "find",
+        label: "find",
+        description: "Find files matching a glob pattern.",
+        parameters: Type2.Object({
+          pattern: Type2.String(),
+          path: Type2.Optional(Type2.String()),
+          limit: Type2.Optional(Type2.Number())
+        }),
+        async execute(toolCallId, params) {
+          const denied = await maybeDenyPiBuiltinTool({
+            toolCallId,
+            nativeName: "find",
+            requestApproval: input.requestApproval
+          });
+          if (denied) return denied;
+          const matches = await input.remoteOps.findFiles(
+            params.pattern,
+            params.path ?? ".",
+            params.limit ?? 1e3
+          );
+          return asPiToolResult(matches.join("\n"));
+        }
+      });
+    case "ls":
+      return defineTool({
+        name: "ls",
+        label: "ls",
+        description: "List directory entries.",
+        parameters: Type2.Object({
+          path: Type2.Optional(Type2.String()),
+          limit: Type2.Optional(Type2.Number())
+        }),
+        async execute(toolCallId, params) {
+          const denied = await maybeDenyPiBuiltinTool({
+            toolCallId,
+            nativeName: "ls",
+            requestApproval: input.requestApproval
+          });
+          if (denied) return denied;
+          const entries = await input.remoteOps.listDirectory(
+            params.path ?? ".",
+            params.limit ?? 500
+          );
+          return asPiToolResult(entries.join("\n"));
+        }
+      });
+  }
+}
+function buildUserToolDefinition(spec, pending) {
+  const schema = spec.inputSchema ?? {
+    type: "object",
+    properties: {},
+    additionalProperties: true
+  };
+  return defineTool({
+    name: spec.name,
+    label: spec.name,
+    description: spec.description ?? `User-registered tool ${spec.name}`,
+    parameters: toolSpecToTypeBoxParameters(schema),
+    async execute(toolCallId) {
+      return new Promise((resolve) => {
+        pending.set(toolCallId, { resolve });
+      }).then((output) => asPiToolResult(serializeToolOutput(output)));
+    }
+  });
+}
+
+// src/pi-harness.ts
+var PI_BUILTIN_TOOLS = {
+  read: commonTool("read", {
+    nativeName: "read",
+    toolUseKind: "readonly",
+    description: "Read file contents.",
+    inputSchema: z3.object({
+      file_path: z3.string()
+    })
+  }),
+  write: commonTool("write", {
+    nativeName: "write",
+    toolUseKind: "edit",
+    description: "Overwrite or create a file.",
+    inputSchema: z3.object({
+      file_path: z3.string(),
+      content: z3.string()
+    })
+  }),
+  edit: commonTool("edit", {
+    nativeName: "edit",
+    toolUseKind: "edit",
+    description: "Edit a file by exact string replacement.",
+    inputSchema: z3.object({
+      file_path: z3.string(),
+      old_string: z3.string(),
+      new_string: z3.string()
+    })
+  }),
+  bash: commonTool("bash", {
+    nativeName: "bash",
+    toolUseKind: "bash",
+    description: "Execute a shell command in the sandbox.",
+    inputSchema: z3.object({
+      command: z3.string(),
+      timeout: z3.number().optional()
+    })
+  }),
+  grep: commonTool("grep", {
+    nativeName: "grep",
+    toolUseKind: "readonly",
+    description: "Search file contents with regex.",
+    inputSchema: z3.object({
+      pattern: z3.string(),
+      path: z3.string().optional(),
+      glob: z3.string().optional(),
+      ignoreCase: z3.boolean().optional(),
+      literal: z3.boolean().optional(),
+      context: z3.number().optional(),
+      limit: z3.number().optional()
+    })
+  }),
+  glob: commonTool("glob", {
+    nativeName: "find",
+    toolUseKind: "readonly",
+    description: "Find files matching a glob pattern.",
+    inputSchema: z3.object({
+      pattern: z3.string(),
+      path: z3.string().optional(),
+      limit: z3.number().optional()
+    })
+  }),
+  ls: {
+    ...tool({
+      description: "List directory entries.",
+      inputSchema: z3.object({
+        path: z3.string().optional(),
+        limit: z3.number().optional()
+      }),
+      outputSchema: z3.unknown()
+    }),
+    nativeName: "ls",
+    toolUseKind: "readonly"
+  }
+};
+function createPi(settings = {}) {
+  return {
+    specificationVersion: "harness-v1",
+    harnessId: "pi",
+    builtinTools: PI_BUILTIN_TOOLS,
+    supportsBuiltinToolApprovals: true,
+    lifecycleStateSchema: piResumeStateSchema,
+    doStart: async (startOpts) => {
+      const lifecycleState = startOpts.continueFrom ?? startOpts.resumeFrom;
+      const resumeData = lifecycleState?.data;
+      return createPiSession({
+        sessionId: startOpts.sessionId,
+        sandboxSession: startOpts.sandboxSession,
+        sessionWorkDir: startOpts.sessionWorkDir,
+        skills: startOpts.skills ?? [],
+        settings: {
+          ...settings.auth ? { auth: settings.auth } : {},
+          ...settings.model ? { model: settings.model } : {},
+          ...settings.thinkingLevel ? { thinkingLevel: settings.thinkingLevel } : {}
+        },
+        isResume: lifecycleState != null,
+        permissionMode: startOpts.permissionMode,
+        ...resumeData?.sessionFileName ? { resumeSessionFileName: resumeData.sessionFileName } : {},
+        ...startOpts.abortSignal ? { abortSignal: startOpts.abortSignal } : {}
+      });
+    }
+  };
+}
+
+// src/index.ts
+var pi = createPi();
+export {
+  createPi,
+  pi
+};
+//# sourceMappingURL=index.js.map