@ai-sdk/harness-deepagents 0.0.0 → 1.0.1

package/dist/index.js

@@ -0,0 +1,741 @@
+// src/deepagents-harness.ts
+import { randomBytes } from "crypto";
+import { readFile } from "fs/promises";
+import { fileURLToPath } from "url";
+import {
+  commonTool,
+  HarnessCapabilityUnsupportedError,
+  harnessV1DiagnosticFromBridgeFrame
+} from "@ai-sdk/harness";
+import {
+  markBridgeStarting,
+  SandboxChannel,
+  waitForBridgeReady
+} from "@ai-sdk/harness/utils";
+import { tool } from "@ai-sdk/provider-utils";
+import { WebSocket } from "ws";
+import { z as z2 } from "zod";
+
+// src/deepagents-auth.ts
+import { getAiGatewayAuthFromEnv } from "@ai-sdk/harness/utils";
+function resolveDeepAgentsEnv({
+  auth,
+  processEnv = process.env
+}) {
+  if (auth?.anthropic) {
+    return pickAnthropic({ explicit: auth.anthropic, processEnv });
+  }
+  const gatewayAuthFromEnv = getAiGatewayAuthFromEnv({ env: processEnv });
+  if (auth?.gateway) {
+    return pickGateway({ explicit: auth.gateway, gatewayAuthFromEnv });
+  }
+  if (gatewayAuthFromEnv.apiKey) {
+    return pickGateway({ explicit: {}, gatewayAuthFromEnv });
+  }
+  return pickAnthropic({ processEnv });
+}
+function pickAnthropic({
+  explicit,
+  processEnv
+}) {
+  const env = {};
+  const apiKey = explicit?.apiKey ?? processEnv.ANTHROPIC_API_KEY;
+  if (apiKey) env.ANTHROPIC_API_KEY = apiKey;
+  const authToken = explicit?.authToken ?? processEnv.ANTHROPIC_AUTH_TOKEN;
+  if (authToken) env.ANTHROPIC_AUTH_TOKEN = authToken;
+  const baseUrl = explicit?.baseUrl ?? processEnv.ANTHROPIC_BASE_URL;
+  if (baseUrl) env.ANTHROPIC_BASE_URL = baseUrl;
+  return env;
+}
+function pickGateway({
+  explicit,
+  gatewayAuthFromEnv
+}) {
+  const apiKey = explicit.apiKey ?? gatewayAuthFromEnv.apiKey;
+  const baseUrl = (explicit.baseUrl ?? gatewayAuthFromEnv.baseUrl).replace(
+    /\/+$/,
+    ""
+  );
+  const env = {};
+  if (apiKey) {
+    env.AI_GATEWAY_API_KEY = apiKey;
+    env.ANTHROPIC_API_KEY = apiKey;
+  }
+  env.ANTHROPIC_BASE_URL = baseUrl;
+  return env;
+}
+
+// src/deepagents-bridge-protocol.ts
+import {
+  harnessV1BridgeInboundCommandSchemas,
+  harnessV1BridgeOutboundMessageSchema,
+  harnessV1BridgeReadySchema,
+  harnessV1BridgeStartBaseSchema
+} from "@ai-sdk/harness";
+import { z } from "zod/v4";
+var outboundMessageSchema = harnessV1BridgeOutboundMessageSchema;
+var startMessageSchema = harnessV1BridgeStartBaseSchema.extend({
+  // Prepended to the first user message (createDeepAgent takes no instructions param).
+  instructions: z.string().optional(),
+  // In-backend skills source dirs ($HOME and <workDir>), passed to createDeepAgent({ skills }).
+  skillsPaths: z.array(z.string()).optional(),
+  // Max LangGraph super-steps per turn (streamEvents recursionLimit).
+  recursionLimit: z.number().optional()
+});
+var inboundMessageSchema = z.discriminatedUnion("type", [
+  startMessageSchema,
+  ...harnessV1BridgeInboundCommandSchemas
+]);
+
+// src/deepagents-harness.ts
+var BOOTSTRAP_DIR = "/tmp/harness/deepagents";
+var RIPGREP_VERSION = "14.1.1";
+var RIPGREP_SHA256_X64 = "4cf9f2741e6c465ffdb7c26f38056a59e2a2544b51f7cc128ef28337eeae4d8e";
+var RIPGREP_SHA256_ARM = "c827481c4ff4ea10c9dc7a4022c8de5db34a5737cb74484d62eb94a95841ab2f";
+function installRipgrepCommand() {
+  const v = RIPGREP_VERSION;
+  return [
+    "command -v rg >/dev/null 2>&1 || {",
+    'case "$(uname -m)" in',
+    `aarch64) a=aarch64-unknown-linux-gnu; sha=${RIPGREP_SHA256_ARM} ;;`,
+    `*) a=x86_64-unknown-linux-musl; sha=${RIPGREP_SHA256_X64} ;;`,
+    "esac;",
+    `f=/tmp/ripgrep-${v}.tar.gz;`,
+    `curl -fsSL "https://github.com/BurntSushi/ripgrep/releases/download/${v}/ripgrep-${v}-$a.tar.gz" -o "$f"`,
+    '&& echo "$sha  $f" | sha256sum -c -',
+    '&& tar xzf "$f" -C /tmp',
+    `&& mv "/tmp/ripgrep-${v}-$a/rg" /usr/local/bin/rg && chmod +x /usr/local/bin/rg;`,
+    "}"
+  ].join(" ");
+}
+var SKILLS_SOURCE_PATH = "/.agents/skills";
+var deepAgentsBridgeCoordsSchema = z2.object({
+  port: z2.number(),
+  token: z2.string(),
+  lastSeenEventId: z2.number(),
+  sandboxId: z2.string().optional()
+});
+var deepAgentsResumeStateSchema = z2.object({
+  bridge: deepAgentsBridgeCoordsSchema.optional()
+});
+var DEEPAGENTS_BUILTIN_TOOLS = {
+  read: commonTool("read", {
+    nativeName: "read_file",
+    toolUseKind: "readonly",
+    description: "Read file contents",
+    inputSchema: z2.object({ file_path: z2.string() })
+  }),
+  write: commonTool("write", {
+    nativeName: "write_file",
+    toolUseKind: "edit",
+    description: "Create a file",
+    inputSchema: z2.object({ file_path: z2.string(), content: z2.string() })
+  }),
+  edit: commonTool("edit", {
+    nativeName: "edit_file",
+    toolUseKind: "edit",
+    description: "Perform exact string replacements in a file",
+    inputSchema: z2.object({
+      file_path: z2.string(),
+      old_string: z2.string(),
+      new_string: z2.string()
+    })
+  }),
+  bash: commonTool("bash", {
+    nativeName: "execute",
+    toolUseKind: "bash",
+    description: "Run a shell command",
+    inputSchema: z2.object({ command: z2.string() })
+  }),
+  grep: commonTool("grep", {
+    nativeName: "grep",
+    toolUseKind: "readonly",
+    description: "Search file contents",
+    inputSchema: z2.object({ pattern: z2.string() })
+  }),
+  glob: commonTool("glob", {
+    nativeName: "glob",
+    toolUseKind: "readonly",
+    description: "Find files matching a glob pattern",
+    inputSchema: z2.object({ pattern: z2.string() })
+  }),
+  // No common-name equivalent — keyed by native name.
+  ls: tool({
+    description: "List files in a directory",
+    inputSchema: z2.object({ path: z2.string().optional() })
+  }),
+  task: tool({
+    description: "Spawn a subagent to handle a delegated task",
+    inputSchema: z2.object({
+      description: z2.string().optional(),
+      subagent_type: z2.string().optional()
+    })
+  }),
+  write_todos: tool({
+    description: "Manage a structured todo list",
+    inputSchema: z2.object({ todos: z2.array(z2.unknown()).optional() })
+  })
+};
+function createDeepAgents(settings = {}) {
+  let cachedBootstrap;
+  return {
+    specificationVersion: "harness-v1",
+    harnessId: "deepagents",
+    builtinTools: DEEPAGENTS_BUILTIN_TOOLS,
+    // Built-in tool approvals are gated in-bridge via DeepAgents' interruptOn (HITL) middleware.
+    supportsBuiltinToolApprovals: true,
+    lifecycleStateSchema: deepAgentsResumeStateSchema,
+    getBootstrap: async () => {
+      if (cachedBootstrap != null) return cachedBootstrap;
+      const [bridge, pkg, lock] = await Promise.all([
+        readBridgeAsset("index.mjs"),
+        readBridgeAsset("package.json"),
+        readBridgeAsset("pnpm-lock.yaml")
+      ]);
+      cachedBootstrap = {
+        harnessId: "deepagents",
+        bootstrapDir: BOOTSTRAP_DIR,
+        files: [
+          { path: `${BOOTSTRAP_DIR}/bridge.mjs`, content: bridge },
+          { path: `${BOOTSTRAP_DIR}/package.json`, content: pkg },
+          { path: `${BOOTSTRAP_DIR}/pnpm-lock.yaml`, content: lock }
+        ],
+        commands: [
+          { command: `mkdir -p ${BOOTSTRAP_DIR}` },
+          { command: installRipgrepCommand() },
+          {
+            command: `pnpm --dir ${BOOTSTRAP_DIR} install --frozen-lockfile --store-dir ${BOOTSTRAP_DIR}/.pnpm-store`
+          }
+        ]
+      };
+      return cachedBootstrap;
+    },
+    doStart: async (startOpts) => {
+      const permissionMode = startOpts.permissionMode;
+      const sandboxSession = startOpts.sandboxSession;
+      const session = sandboxSession.restricted();
+      const sandboxId = sandboxSession.id;
+      const lifecycleState = startOpts.continueFrom ?? startOpts.resumeFrom;
+      const isResume = lifecycleState != null;
+      const isContinue = startOpts.continueFrom != null;
+      const coords = isResume && typeof lifecycleState?.data === "object" ? lifecycleState.data.bridge : void 0;
+      const workDir = startOpts.sessionWorkDir;
+      const sessionDataDir = `${sandboxSession.defaultWorkingDirectory}/.agent-runs/${startOpts.sessionId}`;
+      const bridgeStateDir = `${sessionDataDir}/bridge`;
+      const timeoutMs = settings.startupTimeoutMs ?? 12e4;
+      const report = startOpts.observability?.report;
+      const onDiagnostic = report ? (frame) => report(
+        harnessV1DiagnosticFromBridgeFrame(frame, {
+          sessionId: startOpts.sessionId,
+          timestamp: Date.now()
+        })
+      ) : void 0;
+      if (coords) {
+        try {
+          const attachUrl = await sandboxSession.getPortUrl({
+            port: coords.port,
+            protocol: "ws"
+          }) + `?agent_bridge_token=${encodeURIComponent(coords.token)}`;
+          const attachChannel = new SandboxChannel({
+            connect: () => openWebSocket(attachUrl),
+            outboundSchema: outboundMessageSchema,
+            initialLastSeenEventId: coords.lastSeenEventId,
+            onDiagnostic
+          });
+          await attachChannel.open(isContinue ? { resume: true } : void 0);
+          return createSession({
+            sessionId: startOpts.sessionId,
+            channel: attachChannel,
+            proc: void 0,
+            model: settings.model,
+            bridgePort: coords.port,
+            bridgeToken: coords.token,
+            sandboxId,
+            isResume: true,
+            attached: true,
+            permissionMode,
+            recursionLimit: settings.recursionLimit
+          });
+        } catch {
+        }
+      }
+      const port = resolveBridgePort(sandboxSession, settings.port);
+      const token = randomBytes(32).toString("hex");
+      const skillsPaths = [`${workDir}${SKILLS_SOURCE_PATH}`];
+      if ((startOpts.skills?.length ?? 0) > 0) {
+        const homeDir = await resolveSandboxHomeDir({
+          sandbox: session,
+          abortSignal: startOpts.abortSignal
+        });
+        const homeSkillsRoot = `${homeDir}${SKILLS_SOURCE_PATH}`;
+        await writeSkills({
+          sandbox: session,
+          root: homeSkillsRoot,
+          skills: startOpts.skills ?? [],
+          abortSignal: startOpts.abortSignal
+        });
+        skillsPaths.push(homeSkillsRoot);
+      }
+      const env = {
+        ...resolveDeepAgentsEnv({ auth: settings.auth }),
+        BRIDGE_CHANNEL_TOKEN: token,
+        BRIDGE_WS_PORT: String(port)
+      };
+      await session.run({
+        command: `mkdir -p ${shellQuote(workDir)} ${shellQuote(bridgeStateDir)}`,
+        abortSignal: startOpts.abortSignal
+      });
+      await markBridgeStarting({
+        sandbox: session,
+        bridgeStateDir,
+        bridgeType: "deepagents",
+        abortSignal: startOpts.abortSignal
+      });
+      const proc = await session.spawn({
+        command: `node ${BOOTSTRAP_DIR}/bridge.mjs --workdir ${shellQuote(workDir)} --bridge-state-dir ${shellQuote(bridgeStateDir)} --bootstrap-dir ${shellQuote(BOOTSTRAP_DIR)}`,
+        env,
+        abortSignal: startOpts.abortSignal
+      });
+      const { port: boundPort } = await waitForBridgeReady({
+        proc,
+        sandbox: session,
+        bridgeStateDir,
+        bridgeType: "deepagents",
+        timeoutMs,
+        abortSignal: startOpts.abortSignal,
+        createTimeoutError: () => new Error("deepagents bridge did not become ready in time."),
+        createExitError: () => new Error("deepagents bridge exited before becoming ready.")
+      });
+      void forwardBridgeStderr(proc.stderr);
+      const wsUrl = await sandboxSession.getPortUrl({
+        port: boundPort,
+        protocol: "ws"
+      }) + `?agent_bridge_token=${encodeURIComponent(token)}`;
+      const channel = new SandboxChannel({
+        connect: () => openWebSocket(wsUrl),
+        outboundSchema: outboundMessageSchema,
+        onDiagnostic
+      });
+      await channel.open();
+      return createSession({
+        sessionId: startOpts.sessionId,
+        channel,
+        proc,
+        model: settings.model,
+        bridgePort: boundPort,
+        bridgeToken: token,
+        sandboxId,
+        isResume,
+        // Freshly spawned bridge — it must receive the instructions on the first prompt.
+        attached: false,
+        skillsPaths,
+        permissionMode,
+        recursionLimit: settings.recursionLimit
+      });
+    }
+  };
+}
+function resolveBridgePort(sandboxSession, override) {
+  if (override !== void 0) return override;
+  if (sandboxSession.ports.length > 0) return sandboxSession.ports[0];
+  throw new HarnessCapabilityUnsupportedError({
+    harnessId: "deepagents",
+    message: "The deepagents harness needs a TCP port exposed by the sandbox. Create the sandbox with `ports: [<port>]` or pass `createDeepAgents({ port })`."
+  });
+}
+async function readBridgeAsset(name) {
+  const candidates = [
+    new URL(`./bridge/${name}`, import.meta.url),
+    new URL(`../bridge/${name}`, import.meta.url)
+  ];
+  let lastErr;
+  for (const url of candidates) {
+    try {
+      return await readFile(fileURLToPath(url), "utf8");
+    } catch (err) {
+      const code = err.code;
+      if (code !== "ENOENT") throw err;
+      lastErr = err;
+    }
+  }
+  throw lastErr ?? new Error(`bridge asset not found: ${name}`);
+}
+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.startsWith("/")) {
+    throw new Error(
+      `Unable to resolve sandbox HOME directory: ${result.stderr || result.stdout}`
+    );
+  }
+  return homeDir;
+}
+async function writeSkills({
+  sandbox,
+  root,
+  skills,
+  abortSignal
+}) {
+  for (const skill of skills) {
+    const name = safeSkillName(skill.name);
+    const skillDir = `${root}/${name}`;
+    const content = `---
+name: ${name}
+description: ${skill.description}
+---
+
+${skill.content}`;
+    await sandbox.writeTextFile({
+      path: `${skillDir}/SKILL.md`,
+      content,
+      abortSignal
+    });
+    for (const file of skill.files ?? []) {
+      await sandbox.writeTextFile({
+        path: `${skillDir}/${safeSkillFilePath(name, file.path)}`,
+        content: file.content,
+        abortSignal
+      });
+    }
+  }
+}
+function safeSkillName(name) {
+  if (!/^[a-z0-9]([a-z0-9-]{0,62}[a-z0-9])?$/.test(name)) {
+    throw new Error(
+      `Invalid deepagents skill name '${name}': must be lowercase alphanumeric with hyphens, 1-64 chars.`
+    );
+  }
+  return name;
+}
+function safeSkillFilePath(skillName, filePath) {
+  const normalized = filePath.replace(/^\/+/, "");
+  if (normalized === "" || normalized.startsWith("../") || normalized.includes("/../") || normalized.endsWith("/..")) {
+    throw new Error(`Invalid skill file path for '${skillName}': ${filePath}`);
+  }
+  return normalized;
+}
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function openWebSocket(url) {
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(url);
+    const onOpen = () => {
+      ws.off("error", onError);
+      resolve(ws);
+    };
+    const onError = (err) => {
+      ws.off("open", onOpen);
+      reject(err);
+    };
+    ws.once("open", onOpen);
+    ws.once("error", onError);
+  });
+}
+async function forwardBridgeStderr(stream) {
+  try {
+    const reader = stream.pipeThrough(new TextDecoderStream()).getReader();
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) return;
+      if (value) {
+        const trimmed = value.endsWith("\n") ? value.slice(0, -1) : value;
+        if (trimmed.length > 0) {
+          console.log(`[bridge stderr] ${trimmed}`);
+        }
+      }
+    }
+  } catch {
+  }
+}
+function createSession({
+  sessionId,
+  channel,
+  proc,
+  model,
+  bridgePort,
+  bridgeToken,
+  sandboxId,
+  isResume,
+  attached,
+  skillsPaths,
+  permissionMode,
+  recursionLimit
+}) {
+  let stopped = false;
+  let instructionsApplied = attached;
+  const wireTurn = (turnOpts) => {
+    let pendingResolve;
+    let pendingReject;
+    const done = new Promise((resolve, reject) => {
+      pendingResolve = resolve;
+      pendingReject = reject;
+    });
+    const unsubs = [];
+    const forward = (event) => {
+      try {
+        turnOpts.emit(event);
+      } catch {
+      }
+    };
+    const eventTypes = [
+      "stream-start",
+      "text-start",
+      "text-delta",
+      "text-end",
+      "reasoning-start",
+      "reasoning-delta",
+      "reasoning-end",
+      "tool-call",
+      "tool-approval-request",
+      "tool-result",
+      "file-change",
+      "finish-step",
+      "raw"
+    ];
+    let isSettled = false;
+    const settleSuccess = () => {
+      if (isSettled) return;
+      isSettled = true;
+      for (const u of unsubs) u();
+      pendingResolve();
+    };
+    const settleError = (err) => {
+      if (isSettled) return;
+      isSettled = true;
+      for (const u of unsubs) u();
+      pendingReject(err);
+    };
+    for (const type of eventTypes) {
+      unsubs.push(channel.on(type, (msg) => forward(msg)));
+    }
+    unsubs.push(
+      channel.on("finish", (msg) => {
+        forward(msg);
+        settleSuccess();
+      })
+    );
+    unsubs.push(
+      channel.on("error", (msg) => {
+        forward(msg);
+        settleError(msg.error);
+      })
+    );
+    const onClose = (_code, reason) => {
+      if (isSettled) return;
+      if (reason === "suspended") {
+        settleSuccess();
+        return;
+      }
+      settleError(
+        new Error("deepagents bridge closed before the turn finished.")
+      );
+    };
+    channel.onClose(onClose);
+    const onAbort = () => {
+      if (isSettled) return;
+      try {
+        channel.send({ type: "abort" });
+      } catch {
+      }
+      settleError(
+        turnOpts.abortSignal?.reason ?? new DOMException("Aborted", "AbortError")
+      );
+    };
+    if (turnOpts.abortSignal) {
+      if (turnOpts.abortSignal.aborted) {
+        onAbort();
+      } else {
+        turnOpts.abortSignal.addEventListener("abort", onAbort, { once: true });
+      }
+    }
+    return {
+      submitToolResult: async (input) => {
+        channel.send({
+          type: "tool-result",
+          toolCallId: input.toolCallId,
+          output: input.output,
+          isError: input.isError
+        });
+      },
+      submitUserMessage: async (text) => {
+        channel.send({ type: "user-message", text });
+      },
+      submitToolApproval: async (input) => {
+        channel.send({
+          type: "tool-approval-response",
+          approvalId: input.approvalId,
+          approved: input.approved,
+          ...input.reason != null ? { reason: input.reason } : {}
+        });
+      },
+      done
+    };
+  };
+  const unsupported = (capability) => {
+    throw new HarnessCapabilityUnsupportedError({
+      harnessId: "deepagents",
+      message: `Harness 'deepagents' does not support ${capability} yet.`
+    });
+  };
+  return {
+    sessionId,
+    isResume,
+    modelId: model,
+    doPromptTurn: async (promptOpts) => {
+      const control = wireTurn({
+        emit: promptOpts.emit,
+        abortSignal: promptOpts.abortSignal
+      });
+      const applyInstructions = !instructionsApplied && !!promptOpts.instructions;
+      instructionsApplied = true;
+      channel.send({
+        type: "start",
+        prompt: extractUserText(promptOpts.prompt),
+        ...applyInstructions ? { instructions: promptOpts.instructions } : {},
+        tools: (promptOpts.tools ?? []).map((t) => ({
+          name: t.name,
+          description: t.description,
+          inputSchema: t.inputSchema
+        })),
+        ...model ? { model } : {},
+        ...skillsPaths?.length ? { skillsPaths } : {},
+        ...permissionMode ? { permissionMode } : {},
+        ...recursionLimit != null ? { recursionLimit } : {}
+      });
+      return control;
+    },
+    doContinueTurn: async (continueOpts) => {
+      return wireTurn({
+        emit: continueOpts.emit,
+        abortSignal: continueOpts.abortSignal
+      });
+    },
+    doSuspendTurn: async () => {
+      if (stopped) {
+        throw new Error(
+          `deepagents session ${sessionId} is stopped; cannot suspend.`
+        );
+      }
+      stopped = true;
+      const lastSeenEventId = await channel.suspend();
+      const payload = {
+        type: "continue-turn",
+        harnessId: "deepagents",
+        specificationVersion: "harness-v1",
+        data: {
+          bridge: {
+            port: bridgePort,
+            token: bridgeToken,
+            lastSeenEventId,
+            sandboxId
+          }
+        }
+      };
+      return payload;
+    },
+    doDetach: async () => {
+      if (stopped) {
+        throw new Error(
+          `deepagents session ${sessionId} is already stopped; cannot detach.`
+        );
+      }
+      stopped = true;
+      const lastSeenEventId = await channel.suspend();
+      const payload = {
+        type: "resume-session",
+        harnessId: "deepagents",
+        specificationVersion: "harness-v1",
+        data: {
+          bridge: {
+            port: bridgePort,
+            token: bridgeToken,
+            lastSeenEventId,
+            sandboxId
+          }
+        }
+      };
+      return payload;
+    },
+    doCompact: async () => unsupported("manual compaction"),
+    doStop: async () => {
+      if (stopped) {
+        throw new Error(
+          `deepagents session ${sessionId} is already stopped; cannot stop.`
+        );
+      }
+      stopped = true;
+      await teardown(channel, proc);
+      const payload = {
+        type: "resume-session",
+        harnessId: "deepagents",
+        specificationVersion: "harness-v1",
+        data: {}
+      };
+      return payload;
+    },
+    doDestroy: async () => {
+      if (stopped) return;
+      stopped = true;
+      await teardown(channel, proc);
+    }
+  };
+}
+async function teardown(channel, proc) {
+  channel.beginClose();
+  try {
+    if (!channel.isClosed()) {
+      channel.send({ type: "shutdown" });
+    }
+  } catch {
+  }
+  let stopTimer;
+  try {
+    if (proc) {
+      await Promise.race([
+        proc.wait(),
+        new Promise((resolve) => {
+          stopTimer = setTimeout(resolve, 5e3);
+          stopTimer.unref?.();
+        })
+      ]);
+    }
+  } finally {
+    if (stopTimer) clearTimeout(stopTimer);
+    try {
+      await proc?.kill();
+    } catch {
+    }
+    channel.close();
+  }
+}
+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({
+        harnessId: "deepagents",
+        message: `The deepagents harness does not yet support user message parts of type '${part.type}'. Pass a string or a user message whose content contains only text parts.`
+      });
+    }
+    parts.push(part.text);
+  }
+  return parts.join("\n\n");
+}
+
+// src/index.ts
+var deepAgents = createDeepAgents();
+export {
+  createDeepAgents,
+  deepAgents
+};
+//# sourceMappingURL=index.js.map