@ai-sdk/harness-cline 0.0.0 → 1.0.0

package/dist/index.js

@@ -0,0 +1,1587 @@
+// src/cline-harness.ts
+import {
+  commonTool
+} from "@ai-sdk/harness";
+import { tool } from "@ai-sdk/provider-utils";
+import { z as z2 } from "zod/v4";
+
+// src/cline-auth.ts
+import { getAiGatewayAuthFromEnv } from "@ai-sdk/harness/utils";
+function resolveClineEnv({
+  auth = "auto",
+  env = process.env
+}) {
+  if (auth === "direct") {
+    return pickDirectClineEnv({ env });
+  }
+  const gatewayAuth = getAiGatewayAuthFromEnv({ env });
+  if (auth === "ai-gateway" || gatewayAuth.apiKey) {
+    return {
+      ...gatewayAuth.apiKey ? { AI_GATEWAY_API_KEY: gatewayAuth.apiKey } : {},
+      AI_GATEWAY_BASE_URL: gatewayAuth.baseUrl
+    };
+  }
+  return pickDirectClineEnv({ env });
+}
+function pickDirectClineEnv({
+  env
+}) {
+  return {
+    ...env.CLINE_API_KEY ? { CLINE_API_KEY: env.CLINE_API_KEY } : {},
+    ...env.CLINE_API_BASE_URL ? { CLINE_API_BASE_URL: env.CLINE_API_BASE_URL } : {}
+  };
+}
+
+// src/cline-resume-state.ts
+import { createHash } from "crypto";
+import path from "path";
+import {
+  safeParseJSON
+} from "@ai-sdk/provider-utils";
+import { z } from "zod/v4";
+var CLINE_HISTORY_FILE_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*\.json$/;
+function safeClineHistoryFileName(historyFileName) {
+  if (!CLINE_HISTORY_FILE_NAME_PATTERN.test(historyFileName)) {
+    throw new Error(`Invalid Cline history file name: ${historyFileName}`);
+  }
+  return historyFileName;
+}
+var clineHistoryFileNameSchema = z.string().refine(
+  (historyFileName) => CLINE_HISTORY_FILE_NAME_PATTERN.test(historyFileName),
+  "Cline historyFileName must be a safe .json basename."
+);
+var clineResumeStateSchema = z.looseObject({
+  historyFileName: clineHistoryFileNameSchema.optional()
+});
+var CLINE_DEFAULT_HISTORY_FILE_NAME = "history.json";
+function resolveClinePrivateSessionDirectory(input) {
+  const sessionKey = createHash("sha256").update(input.sessionId).digest("hex");
+  const privateSessionDir = path.posix.join(
+    input.sandboxHomeDir,
+    ".ai-sdk",
+    "harness-cline",
+    sessionKey
+  );
+  const relativePath = path.posix.relative(
+    input.sessionWorkDir,
+    privateSessionDir
+  );
+  if (relativePath === "" || !relativePath.startsWith("../") && !path.posix.isAbsolute(relativePath)) {
+    throw new Error(
+      `Cline private session directory ${JSON.stringify(privateSessionDir)} must be outside sessionWorkDir ${JSON.stringify(input.sessionWorkDir)}.`
+    );
+  }
+  return privateSessionDir;
+}
+function resolveContainedSandboxPath(input) {
+  const historyDir = path.posix.resolve(input.privateSessionDir);
+  const filePath = path.posix.resolve(
+    historyDir,
+    safeClineHistoryFileName(input.historyFileName)
+  );
+  const relativePath = path.posix.relative(historyDir, filePath);
+  if (relativePath === "" || relativePath.startsWith("..") || path.posix.isAbsolute(relativePath)) {
+    throw new Error(
+      `Invalid Cline history file name: ${input.historyFileName}`
+    );
+  }
+  return filePath;
+}
+async function persistHistoryToSandbox(args) {
+  const remotePath = resolveContainedSandboxPath({
+    privateSessionDir: args.privateSessionDir,
+    historyFileName: args.historyFileName
+  });
+  await args.sandbox.writeTextFile({
+    path: remotePath,
+    content: JSON.stringify(args.messages),
+    ...args.abortSignal ? { abortSignal: args.abortSignal } : {}
+  });
+}
+async function pullHistoryFromSandbox(args) {
+  const remotePath = resolveContainedSandboxPath({
+    privateSessionDir: args.privateSessionDir,
+    historyFileName: args.historyFileName
+  });
+  const content = await args.sandbox.readTextFile({
+    path: remotePath,
+    ...args.abortSignal ? { abortSignal: args.abortSignal } : {}
+  });
+  if (content == null) return void 0;
+  const parsed = await safeParseJSON({ text: content });
+  return parsed.success && Array.isArray(parsed.value) ? parsed.value : void 0;
+}
+
+// src/cline-session.ts
+import {
+  HarnessCapabilityUnsupportedError as HarnessCapabilityUnsupportedError2
+} from "@ai-sdk/harness";
+import { resolveSandboxHomeDir } from "@ai-sdk/harness/utils";
+import {
+  Agent
+} from "@cline/agents";
+import { Llms } from "@cline/core";
+
+// src/cline-mcp.ts
+var CLINE_CORE_PACKAGE = "@cline/core";
+function isRecord(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function optionalStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : void 0;
+}
+function optionalStringRecord(value) {
+  return isRecord(value) && Object.values(value).every((item) => typeof item === "string") ? value : void 0;
+}
+function resolveTransport(input) {
+  if (isRecord(input.config.transport)) {
+    return input.config.transport;
+  }
+  if (typeof input.config.command === "string") {
+    const args = optionalStringArray(input.config.args);
+    const env = optionalStringRecord(input.config.env);
+    return {
+      type: "stdio",
+      command: input.config.command,
+      ...args ? { args } : {},
+      ...typeof input.config.cwd === "string" ? { cwd: input.config.cwd } : {},
+      ...env ? { env } : {}
+    };
+  }
+  if (typeof input.config.url === "string") {
+    const configuredType = input.config.type ?? input.config.transportType;
+    const headers = optionalStringRecord(input.config.headers);
+    return {
+      type: configuredType === "http" || configuredType === "streamableHttp" ? "streamableHttp" : "sse",
+      url: input.config.url,
+      ...headers ? { headers } : {}
+    };
+  }
+  throw new Error(
+    `Cline MCP server ${JSON.stringify(input.serverName)} must define a transport, command, or URL.`
+  );
+}
+function resolveRegistration(input) {
+  if (!isRecord(input.config)) {
+    throw new Error(
+      `Cline MCP server ${JSON.stringify(input.serverName)} must be configured with an object value.`
+    );
+  }
+  return {
+    name: input.serverName,
+    transport: resolveTransport({
+      serverName: input.serverName,
+      config: input.config
+    }),
+    ...typeof input.config.disabled === "boolean" ? { disabled: input.config.disabled } : {},
+    ...isRecord(input.config.metadata) ? { metadata: input.config.metadata } : {},
+    ...isRecord(input.config.oauth) ? { oauth: input.config.oauth } : {}
+  };
+}
+async function createClineMcpRuntime(input) {
+  if (input.mcpServers == null || Object.keys(input.mcpServers).length === 0) {
+    return {
+      tools: [],
+      toolNames: /* @__PURE__ */ new Set(),
+      dispose: async () => {
+      }
+    };
+  }
+  const {
+    createDefaultMcpServerClientFactory,
+    createMcpTools,
+    InMemoryMcpManager
+  } = await import(CLINE_CORE_PACKAGE);
+  const manager = new InMemoryMcpManager({
+    clientFactory: createDefaultMcpServerClientFactory()
+  });
+  const tools = [];
+  try {
+    for (const [serverName, config] of Object.entries(input.mcpServers)) {
+      const registration = resolveRegistration({ serverName, config });
+      await manager.registerServer(registration);
+      if (registration.disabled) continue;
+      tools.push(
+        ...await createMcpTools({
+          serverName,
+          provider: manager
+        })
+      );
+    }
+  } catch (error) {
+    await manager.dispose().catch(() => {
+    });
+    throw error;
+  }
+  return {
+    tools,
+    toolNames: new Set(tools.map((tool2) => tool2.name)),
+    dispose: async () => manager.dispose()
+  };
+}
+
+// src/cline-remote-ops.ts
+import path2 from "path";
+import { shellQuote } from "@ai-sdk/harness/utils";
+function createClineRemoteOps(options) {
+  const { sandbox, workDir } = options;
+  const resolvePath = (inputPath) => {
+    const normalized = path2.posix.isAbsolute(inputPath) ? path2.posix.normalize(inputPath) : path2.posix.normalize(path2.posix.join(workDir, inputPath));
+    return normalized;
+  };
+  const runShell = async (command, input) => {
+    const result = await sandbox.run({
+      command,
+      workingDirectory: workDir,
+      ...input?.signal ? { abortSignal: input.signal } : {}
+    });
+    return {
+      exitCode: result.exitCode,
+      output: `${result.stdout}${result.stderr}`
+    };
+  };
+  const readFile = async (inputPath) => {
+    const resolved = resolvePath(inputPath);
+    const content = await sandbox.readTextFile({ path: resolved });
+    if (content == null) {
+      throw new Error(`File not found: ${inputPath}`);
+    }
+    return content;
+  };
+  const writeFile = async (inputPath, content) => {
+    const resolved = resolvePath(inputPath);
+    await sandbox.writeTextFile({ path: resolved, content });
+  };
+  const editFile = async (inputPath, oldText, newText) => {
+    const current = await readFile(inputPath);
+    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 writeFile(inputPath, updated);
+  };
+  return {
+    resolvePath,
+    readFile,
+    writeFile,
+    editFile,
+    async bash(command, 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, { signal: controller.signal });
+        return { output: result.output, exitCode: result.exitCode };
+      } finally {
+        forwardedSignal?.removeEventListener("abort", onAbort);
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+      }
+    },
+    async grep(pattern, input = {}) {
+      const target = resolvePath(input.path ?? ".");
+      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(
+            target
+          )} ]; then echo "__CLINE_GREP_NOT_FOUND__"; exit 2; fi`,
+          `grep ${flags.map(shellQuote).join(" ")} -- ${shellQuote(
+            pattern
+          )} ${shellQuote(target)} 2>/dev/null | head -n ${limit}`
+        ].join("; ")
+      );
+      const output = result.output.trim();
+      if (output.includes("__CLINE_GREP_NOT_FOUND__")) {
+        throw new Error(`Path not found: ${input.path ?? "."}`);
+      }
+      return output || "No matches found";
+    },
+    async glob(pattern, inputPath = ".", limit = 1e3) {
+      const target = resolvePath(inputPath);
+      const result = await runShell(
+        [
+          `if [ ! -e ${shellQuote(
+            target
+          )} ]; then echo "__CLINE_FIND_NOT_FOUND__"; exit 2; fi`,
+          `if [ -d ${shellQuote(target)} ]; then find ${shellQuote(
+            target
+          )} -type f -print; else printf '%s\\n' ${shellQuote(target)}; fi`
+        ].join("; ")
+      );
+      const output = result.output.trim();
+      if (output.includes("__CLINE_FIND_NOT_FOUND__")) {
+        throw new Error(`Path not found: ${inputPath}`);
+      }
+      return output.split("\n").filter(Boolean).map((absolutePath) => {
+        if (absolutePath === target) {
+          return path2.posix.basename(absolutePath);
+        }
+        return path2.posix.relative(target, absolutePath);
+      }).filter(
+        (candidate) => candidate.length > 0 && path2.matchesGlob(candidate, pattern)
+      ).sort(
+        (left, right) => left.toLowerCase().localeCompare(right.toLowerCase())
+      ).slice(0, limit);
+    },
+    async ls(inputPath = ".", limit = 500) {
+      const target = resolvePath(inputPath);
+      const result = await runShell(
+        [
+          `if [ ! -e ${shellQuote(
+            target
+          )} ]; then echo "__CLINE_LS_NOT_FOUND__"; exit 2; fi`,
+          `if [ ! -d ${shellQuote(
+            target
+          )} ]; then echo "__CLINE_LS_NOT_DIR__"; exit 3; fi`,
+          `cd ${shellQuote(target)}`,
+          "ls -1Ap"
+        ].join("; ")
+      );
+      const output = result.output.trim();
+      if (output.includes("__CLINE_LS_NOT_FOUND__")) {
+        throw new Error(`Path not found: ${inputPath}`);
+      }
+      if (output.includes("__CLINE_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);
+    }
+  };
+}
+
+// src/cline-skills.ts
+import path3 from "path";
+import { writeSkills } from "@ai-sdk/harness/utils";
+async function writeClineSkills({
+  sandbox,
+  sandboxHomeDir,
+  skills,
+  abortSignal
+}) {
+  if (skills.length === 0) return void 0;
+  const skillRootDir = path3.posix.join(sandboxHomeDir, ".agents", "skills");
+  await writeSkills({
+    sandbox,
+    rootDir: skillRootDir,
+    skills,
+    ...abortSignal ? { abortSignal } : {}
+  });
+  return skillRootDir;
+}
+function renderSkillsPromptSection(skills, skillRootDir) {
+  const entries = skills.map(
+    (skill) => `- ${skill.name}: ${skill.description}
+  SKILL.md: ${path3.posix.join(
+      skillRootDir,
+      skill.name,
+      "SKILL.md"
+    )}`
+  ).join("\n");
+  return "## Skills\n\nThe following skills are available. When a task matches a skill, read its SKILL.md with the `read` tool and follow its instructions.\n\n" + entries;
+}
+
+// src/cline-tools.ts
+import {
+  createTool
+} from "@cline/agents";
+
+// src/cline-utils.ts
+import {
+  HarnessCapabilityUnsupportedError
+} from "@ai-sdk/harness";
+import { secureJsonParse } from "@ai-sdk/provider-utils";
+var HARNESS_ID = "cline";
+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: `cline: only text user-message parts are supported; got '${part.type}'.`,
+        harnessId: HARNESS_ID
+      });
+    }
+    parts.push(part.text);
+  }
+  return parts.join("\n\n");
+}
+function getErrorText(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function toToolResultValue(output) {
+  if (output === void 0 || output === null) {
+    return null;
+  }
+  if (typeof output === "string") {
+    return output;
+  }
+  try {
+    const serialized = JSON.stringify(output);
+    return serialized === void 0 ? String(output) : secureJsonParse(serialized);
+  } catch {
+    return String(output);
+  }
+}
+function mapModelFinishReason(reason) {
+  switch (reason) {
+    case "stop":
+      return { unified: "stop", raw: reason };
+    case "tool-calls":
+      return { unified: "tool-calls", raw: reason };
+    case "max-tokens":
+      return { unified: "length", raw: reason };
+    case "error":
+      return { unified: "error", raw: reason };
+    default:
+      return { unified: "other", raw: reason };
+  }
+}
+function mapRunFinishReason(status) {
+  switch (status) {
+    case "completed":
+      return { unified: "stop", raw: status };
+    case "aborted":
+      return { unified: "other", raw: status };
+    case "failed":
+      return { unified: "error", raw: status };
+  }
+}
+function usageFromAgentUsage(usage) {
+  return {
+    inputTokens: {
+      total: usage.inputTokens,
+      noCache: void 0,
+      cacheRead: usage.cacheReadTokens,
+      cacheWrite: usage.cacheWriteTokens
+    },
+    outputTokens: {
+      total: usage.outputTokens,
+      text: void 0,
+      reasoning: usage.reasoningTokenCount
+    },
+    ...usage.totalCost !== void 0 ? { raw: { totalCost: usage.totalCost } } : {}
+  };
+}
+function usageFromMessageMetrics(metrics) {
+  return {
+    inputTokens: {
+      total: metrics?.inputTokens,
+      noCache: void 0,
+      cacheRead: metrics?.cacheReadTokens,
+      cacheWrite: metrics?.cacheWriteTokens
+    },
+    outputTokens: {
+      total: metrics?.outputTokens,
+      text: void 0,
+      reasoning: metrics?.reasoningTokenCount
+    }
+  };
+}
+
+// src/cline-tools.ts
+var CLINE_NATIVE_BUILTIN_NAMES = [
+  "read",
+  "write",
+  "edit",
+  "bash",
+  "grep",
+  "glob",
+  "ls"
+];
+var CLINE_NATIVE_TOOL_KINDS = {
+  read: "readonly",
+  write: "edit",
+  edit: "edit",
+  bash: "bash",
+  grep: "readonly",
+  glob: "readonly",
+  ls: "readonly"
+};
+function isClineBuiltinToolName(name) {
+  return CLINE_NATIVE_BUILTIN_NAMES.includes(name);
+}
+function resolveActiveClineBuiltinNames(toolFiltering) {
+  if (toolFiltering == null) return CLINE_NATIVE_BUILTIN_NAMES;
+  if (toolFiltering.mode === "allow") {
+    return CLINE_NATIVE_BUILTIN_NAMES.filter(
+      (name) => toolFiltering.toolNames.includes(name)
+    );
+  }
+  return CLINE_NATIVE_BUILTIN_NAMES.filter(
+    (name) => !toolFiltering.toolNames.includes(name)
+  );
+}
+var clineToolResultMarker = /* @__PURE__ */ Symbol("cline-tool-result");
+function createClineToolResult({
+  output,
+  isError
+}) {
+  return {
+    [clineToolResultMarker]: true,
+    output,
+    ...isError ? { isError: true } : {}
+  };
+}
+function unwrapClineToolResult(value) {
+  if (value == null || typeof value !== "object" || value[clineToolResultMarker] !== true) {
+    return void 0;
+  }
+  const result = value;
+  return {
+    output: result.output,
+    ...result.isError ? { isError: true } : {}
+  };
+}
+async function guarded(run) {
+  try {
+    return createClineToolResult({ output: await run() });
+  } catch (error) {
+    return createClineToolResult({
+      output: { error: getErrorText(error) },
+      isError: true
+    });
+  }
+}
+function buildBuiltinAgentTools({
+  ops,
+  activeNames
+}) {
+  const tools = {
+    read: createTool({
+      name: "read",
+      description: "Read file contents.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          file_path: {
+            type: "string",
+            description: "Path of the file to read."
+          }
+        },
+        required: ["file_path"]
+      },
+      execute: async (input) => guarded(() => ops.readFile(input.file_path))
+    }),
+    write: createTool({
+      name: "write",
+      description: "Overwrite or create a file.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          file_path: {
+            type: "string",
+            description: "Path of the file to write."
+          },
+          content: {
+            type: "string",
+            description: "Full file content to write."
+          }
+        },
+        required: ["file_path", "content"]
+      },
+      execute: async (input) => guarded(async () => {
+        await ops.writeFile(input.file_path, input.content);
+        return `Wrote ${input.file_path}`;
+      })
+    }),
+    edit: createTool({
+      name: "edit",
+      description: "Edit a file by exact string replacement.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          file_path: {
+            type: "string",
+            description: "Path of the file to edit."
+          },
+          old_string: { type: "string", description: "Exact text to replace." },
+          new_string: { type: "string", description: "Replacement text." }
+        },
+        required: ["file_path", "old_string", "new_string"]
+      },
+      execute: async (input) => guarded(async () => {
+        await ops.editFile(
+          input.file_path,
+          input.old_string,
+          input.new_string
+        );
+        return `Edited ${input.file_path}`;
+      })
+    }),
+    bash: createTool({
+      name: "bash",
+      description: "Execute a shell command in the sandbox workspace. Returns combined stdout/stderr and the exit code.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          command: { type: "string", description: "Shell command to execute." },
+          timeout: {
+            type: "number",
+            description: "Optional timeout in seconds."
+          }
+        },
+        required: ["command"]
+      },
+      execute: async (input, context) => guarded(async () => {
+        const result = await ops.bash(input.command, {
+          ...typeof input.timeout === "number" ? { timeout: input.timeout } : {},
+          ...context.signal ? { signal: context.signal } : {}
+        });
+        return `${result.output}${result.exitCode != null ? `
+
+(exit ${result.exitCode})` : ""}`.trim();
+      })
+    }),
+    grep: createTool({
+      name: "grep",
+      description: "Search file contents with regex.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          pattern: {
+            type: "string",
+            description: "Regex pattern to search for."
+          },
+          path: { type: "string", description: "File or directory to search." },
+          glob: { type: "string", description: "Glob filter for file names." },
+          ignoreCase: { type: "boolean" },
+          literal: {
+            type: "boolean",
+            description: "Treat pattern as a literal string."
+          },
+          context: {
+            type: "number",
+            description: "Lines of context around matches."
+          },
+          limit: {
+            type: "number",
+            description: "Maximum matching lines to return."
+          }
+        },
+        required: ["pattern"]
+      },
+      execute: async (input) => guarded(() => ops.grep(input.pattern, input))
+    }),
+    glob: createTool({
+      name: "glob",
+      description: "Find files matching a glob pattern.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          pattern: { type: "string", description: "Glob pattern to match." },
+          path: { type: "string", description: "Directory to search from." },
+          limit: { type: "number", description: "Maximum paths to return." }
+        },
+        required: ["pattern"]
+      },
+      execute: async (input) => guarded(async () => {
+        const matches = await ops.glob(
+          input.pattern,
+          input.path ?? ".",
+          input.limit ?? 1e3
+        );
+        return matches.length > 0 ? matches.join("\n") : "No files found";
+      })
+    }),
+    ls: createTool({
+      name: "ls",
+      description: "List directory entries.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "Directory to list." },
+          limit: { type: "number", description: "Maximum entries to return." }
+        }
+      },
+      execute: async (input) => guarded(async () => {
+        const entries = await ops.ls(input.path ?? ".", input.limit ?? 500);
+        return entries.join("\n");
+      })
+    })
+  };
+  return activeNames.map((name) => tools[name]).filter((tool2) => tool2 != null);
+}
+function buildUserAgentTools({
+  specs,
+  pendingToolResults
+}) {
+  return specs.map(
+    (spec) => createTool({
+      name: spec.name,
+      description: spec.description ?? `User-registered tool ${spec.name}`,
+      inputSchema: spec.inputSchema ?? {
+        type: "object",
+        properties: {},
+        additionalProperties: true
+      },
+      execute: async (_input, context) => {
+        const toolCallId = context.toolCallId;
+        if (!toolCallId) {
+          return createClineToolResult({
+            output: { error: "Tool call is missing a toolCallId." },
+            isError: true
+          });
+        }
+        return new Promise((resolve) => {
+          pendingToolResults.set(toolCallId, { resolve });
+          context.signal?.addEventListener(
+            "abort",
+            () => {
+              if (pendingToolResults.delete(toolCallId)) {
+                resolve(
+                  createClineToolResult({
+                    output: {
+                      error: "Turn was aborted before a tool result was submitted."
+                    },
+                    isError: true
+                  })
+                );
+              }
+            },
+            { once: true }
+          );
+        });
+      }
+    })
+  );
+}
+
+// src/cline-translate.ts
+function createClineTranslatorState({
+  builtinToolNames,
+  hostToolNames = [],
+  mcpToolNames = []
+}) {
+  return {
+    builtinToolNames: new Set(builtinToolNames),
+    dynamicToolCallIds: /* @__PURE__ */ new Set(),
+    hostToolNames: new Set(hostToolNames),
+    mcpToolNames: new Set(mcpToolNames),
+    emittedToolCalls: /* @__PURE__ */ new Set(),
+    blockCounter: 0
+  };
+}
+function closeOpenBlocks(state) {
+  const parts = [];
+  if (state.openReasoningBlockId) {
+    parts.push({ type: "reasoning-end", id: state.openReasoningBlockId });
+    state.openReasoningBlockId = void 0;
+  }
+  if (state.openTextBlockId) {
+    parts.push({ type: "text-end", id: state.openTextBlockId });
+    state.openTextBlockId = void 0;
+  }
+  return parts;
+}
+function toolCallPart(state, toolCall) {
+  const isMcpTool = state.mcpToolNames.has(toolCall.toolName) && !state.hostToolNames.has(toolCall.toolName);
+  if (isMcpTool) {
+    state.dynamicToolCallIds.add(toolCall.toolCallId);
+  }
+  return {
+    type: "tool-call",
+    toolCallId: toolCall.toolCallId,
+    toolName: toolCall.toolName,
+    input: JSON.stringify(toolCall.input ?? {}),
+    /*
+     * Built-ins and external MCP tools are executed by the Cline runtime.
+     * Typed host tools wait for dispatch through `submitToolResult`, including
+     * when a host tool has the same name as a configured MCP tool.
+     */
+    ...state.builtinToolNames.has(toolCall.toolName) || isMcpTool ? { providerExecuted: true } : {},
+    ...isMcpTool ? { dynamic: true } : {}
+  };
+}
+function toolApprovalParts(state, toolCall) {
+  const parts = [];
+  if (!state.emittedToolCalls.has(toolCall.toolCallId)) {
+    state.emittedToolCalls.add(toolCall.toolCallId);
+    parts.push(toolCallPart(state, toolCall));
+  }
+  parts.push({
+    type: "tool-approval-request",
+    approvalId: toolCall.toolCallId,
+    toolCallId: toolCall.toolCallId
+  });
+  return parts;
+}
+function translateClineEvent(event, state) {
+  switch (event.type) {
+    case "assistant-reasoning-delta": {
+      const parts = [];
+      if (state.openTextBlockId) {
+        parts.push({ type: "text-end", id: state.openTextBlockId });
+        state.openTextBlockId = void 0;
+      }
+      if (!state.openReasoningBlockId) {
+        state.openReasoningBlockId = `reasoning-${++state.blockCounter}`;
+        parts.push({ type: "reasoning-start", id: state.openReasoningBlockId });
+      }
+      parts.push({
+        type: "reasoning-delta",
+        id: state.openReasoningBlockId,
+        delta: event.text
+      });
+      return parts;
+    }
+    case "assistant-text-delta": {
+      const parts = [];
+      if (state.openReasoningBlockId) {
+        parts.push({ type: "reasoning-end", id: state.openReasoningBlockId });
+        state.openReasoningBlockId = void 0;
+      }
+      if (!state.openTextBlockId) {
+        state.openTextBlockId = `text-${++state.blockCounter}`;
+        parts.push({ type: "text-start", id: state.openTextBlockId });
+      }
+      parts.push({
+        type: "text-delta",
+        id: state.openTextBlockId,
+        delta: event.text
+      });
+      return parts;
+    }
+    case "assistant-message": {
+      const parts = closeOpenBlocks(state);
+      state.pendingFinishStep = {
+        type: "finish-step",
+        finishReason: mapModelFinishReason(event.finishReason),
+        usage: usageFromMessageMetrics(event.message.metrics)
+      };
+      return parts;
+    }
+    case "turn-finished": {
+      const pendingFinishStep = state.pendingFinishStep;
+      if (!pendingFinishStep) {
+        return [];
+      }
+      state.pendingFinishStep = void 0;
+      return [pendingFinishStep];
+    }
+    case "tool-started": {
+      if (state.emittedToolCalls.has(event.toolCall.toolCallId)) {
+        return [];
+      }
+      state.emittedToolCalls.add(event.toolCall.toolCallId);
+      return [toolCallPart(state, event.toolCall)];
+    }
+    case "tool-finished": {
+      const resultPart = event.message.content.find(
+        (part) => part.type === "tool-result" && part.toolCallId === event.toolCall.toolCallId
+      );
+      const output = resultPart?.output;
+      const dynamic = state.dynamicToolCallIds.delete(
+        event.toolCall.toolCallId
+      );
+      return [
+        {
+          type: "tool-result",
+          toolCallId: event.toolCall.toolCallId,
+          toolName: event.toolCall.toolName,
+          result: toToolResultValue(output),
+          ...resultPart?.isError ? { isError: true } : {},
+          ...dynamic ? { dynamic: true } : {}
+        }
+      ];
+    }
+    case "tool-updated":
+      return [
+        {
+          type: "raw",
+          rawValue: {
+            type: "tool-updated",
+            toolCallId: event.toolCall.toolCallId,
+            toolName: event.toolCall.toolName,
+            update: event.update
+          }
+        }
+      ];
+    case "status-notice":
+      return [
+        {
+          type: "raw",
+          rawValue: {
+            type: "status-notice",
+            message: event.message,
+            ...event.metadata ? { metadata: event.metadata } : {}
+          }
+        }
+      ];
+    default:
+      return [];
+  }
+}
+function finishClineTranslation(state) {
+  const parts = closeOpenBlocks(state);
+  state.pendingFinishStep = void 0;
+  return parts;
+}
+
+// src/cline-session.ts
+var HARNESS_ID2 = "cline";
+var parkedClineSessions = /* @__PURE__ */ new Map();
+function isAbortError(value) {
+  if (value == null) return false;
+  const name = value.name;
+  if (name === "AbortError" || name === "AgentRuntimeAbortError") {
+    return true;
+  }
+  const text = typeof value === "string" ? value : value instanceof Error ? value.message : String(value);
+  return /\baborted\b|AbortError/i.test(text);
+}
+function clineBuiltinToolRequiresApproval(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 buildSystemPrompt(input) {
+  const sections = [
+    "You are Cline, an autonomous coding agent operating inside a sandboxed workspace.",
+    `## Workspace
+
+The workspace root is \`${input.sessionWorkDir}\`. All relative file paths and shell commands resolve against it. Use the provided tools (read, write, edit, bash, grep, glob, ls) to inspect and modify the workspace.`,
+    `## Sandbox
+
+${input.sandboxDescription}`
+  ];
+  if (input.skillsSection) {
+    sections.push(input.skillsSection);
+  }
+  return sections.join("\n\n");
+}
+function toClineBackendProviderBaseUrl(baseUrl) {
+  return `${baseUrl.replace(/\/+$/, "")}/api/v1`;
+}
+function toAiGatewayProviderBaseUrl(baseUrl) {
+  const trimmed = baseUrl.replace(/\/+$/, "");
+  return trimmed.endsWith("/v1") ? trimmed : `${trimmed}/v1`;
+}
+function createClineAgentModel({
+  settings,
+  clientApp
+}) {
+  const gatewayBaseUrl = settings.authEnv.AI_GATEWAY_BASE_URL;
+  const isAiGateway = gatewayBaseUrl != null;
+  const providerId = isAiGateway ? "cline" : settings.providerId ?? "cline";
+  const apiKey = isAiGateway ? settings.authEnv.AI_GATEWAY_API_KEY : settings.apiKey ?? (providerId === "cline" ? settings.authEnv.CLINE_API_KEY : void 0);
+  const baseUrl = isAiGateway ? toAiGatewayProviderBaseUrl(gatewayBaseUrl) : settings.baseUrl ?? (providerId === "cline" && settings.authEnv.CLINE_API_BASE_URL ? toClineBackendProviderBaseUrl(settings.authEnv.CLINE_API_BASE_URL) : void 0);
+  const headers = isAiGateway ? {
+    ...settings.headers,
+    "User-Agent": clientApp,
+    "x-client-app": clientApp
+  } : settings.headers;
+  const gateway = Llms.createGateway({
+    providerConfigs: [
+      {
+        providerId,
+        ...apiKey ? { apiKey } : {},
+        ...baseUrl ? { baseUrl } : {},
+        ...headers ? { headers } : {},
+        ...isAiGateway ? { apiKeyEnv: [] } : {}
+      }
+    ]
+  });
+  const modelSelection = {
+    providerId,
+    ...settings.modelId ? { modelId: settings.modelId } : {}
+  };
+  const modelOptions = settings.reasoningEffort === "none" ? { reasoning: { enabled: false } } : {
+    reasoning: {
+      enabled: true,
+      effort: settings.reasoningEffort
+    }
+  };
+  const model = settings.reasoningEffort === void 0 ? gateway.createAgentModel(modelSelection) : gateway.createAgentModel(modelSelection, modelOptions);
+  return {
+    model,
+    providerId
+  };
+}
+async function createClineSession(input) {
+  if (input.isResume) {
+    const parkedSession = parkedClineSessions.get(input.sessionId);
+    if (parkedSession) {
+      parkedClineSessions.delete(input.sessionId);
+      return {
+        ...parkedSession,
+        isResume: true
+      };
+    }
+  }
+  const sandbox = input.sandboxSession.restricted();
+  const sandboxHomeDir = await resolveSandboxHomeDir({
+    sandbox,
+    ...input.abortSignal ? { abortSignal: input.abortSignal } : {}
+  });
+  const privateSessionDir = resolveClinePrivateSessionDirectory({
+    sandboxHomeDir,
+    sessionWorkDir: input.sessionWorkDir,
+    sessionId: input.sessionId
+  });
+  const permissionMode = input.permissionMode ?? "allow-all";
+  const activeBuiltinNames = resolveActiveClineBuiltinNames(
+    input.builtinToolFiltering
+  );
+  const ops = createClineRemoteOps({
+    sandbox,
+    workDir: input.sessionWorkDir
+  });
+  let skillsSection;
+  if (input.skills.length > 0) {
+    const skillRootDir = await writeClineSkills({
+      sandbox,
+      sandboxHomeDir,
+      skills: input.skills,
+      ...input.abortSignal ? { abortSignal: input.abortSignal } : {}
+    });
+    if (skillRootDir) {
+      skillsSection = renderSkillsPromptSection(input.skills, skillRootDir);
+    }
+  }
+  const baseSystemPrompt = buildSystemPrompt({
+    sessionWorkDir: input.sessionWorkDir,
+    sandboxDescription: sandbox.description,
+    ...skillsSection ? { skillsSection } : {}
+  });
+  let currentMessages = [];
+  if (input.isResume && input.resumeHistoryFileName) {
+    const restored = await pullHistoryFromSandbox({
+      sandbox,
+      privateSessionDir,
+      historyFileName: safeClineHistoryFileName(input.resumeHistoryFileName),
+      ...input.abortSignal ? { abortSignal: input.abortSignal } : {}
+    });
+    if (restored) {
+      currentMessages = restored;
+    }
+  }
+  const mcpRuntime = await createClineMcpRuntime({
+    mcpServers: input.settings.mcpServers
+  });
+  const { model, providerId } = createClineAgentModel({
+    settings: input.settings,
+    clientApp: input.clientApp
+  });
+  let agent;
+  let unsubscribe;
+  let lastToolsSignature;
+  let agentHasRun = false;
+  let stopped = false;
+  let suspending = false;
+  const pendingToolResults = /* @__PURE__ */ new Map();
+  const pendingToolApprovals = /* @__PURE__ */ new Map();
+  const pendingUserMessages = [];
+  let currentEmit;
+  let translatorState;
+  let activeTurn;
+  function settlePendingToolResults(reason) {
+    for (const pending of pendingToolResults.values()) {
+      pending.resolve(
+        createClineToolResult({
+          output: { error: reason },
+          isError: true
+        })
+      );
+    }
+    pendingToolResults.clear();
+  }
+  function settlePendingToolApprovals(reason) {
+    for (const pending of pendingToolApprovals.values()) {
+      pending.resolve({ approved: false, reason });
+    }
+    pendingToolApprovals.clear();
+  }
+  async function persistHistory() {
+    const messages = agent?.snapshot().messages ?? currentMessages;
+    await persistHistoryToSandbox({
+      sandbox,
+      privateSessionDir,
+      historyFileName: CLINE_DEFAULT_HISTORY_FILE_NAME,
+      messages
+    });
+  }
+  function requestBuiltinToolApproval(toolCall) {
+    if (translatorState && currentEmit) {
+      for (const part of toolApprovalParts(translatorState, toolCall)) {
+        currentEmit(part);
+      }
+    }
+    return new Promise((resolve) => {
+      pendingToolApprovals.set(toolCall.toolCallId, { resolve });
+    });
+  }
+  function rebuildAgent(rebuildInput) {
+    unsubscribe?.();
+    unsubscribe = void 0;
+    agent = new Agent({
+      model,
+      ...input.settings.modelId ? {
+        messageModelInfo: {
+          id: input.settings.modelId,
+          provider: providerId
+        }
+      } : {},
+      sessionId: input.sessionId,
+      systemPrompt: rebuildInput.instructions ? `${baseSystemPrompt}
+
+${rebuildInput.instructions}` : baseSystemPrompt,
+      initialMessages: currentMessages,
+      toolExecution: "parallel",
+      ...input.settings.maxIterations !== void 0 ? { maxIterations: input.settings.maxIterations } : {},
+      tools: [
+        ...buildBuiltinAgentTools({ ops, activeNames: activeBuiltinNames }),
+        ...mcpRuntime.tools,
+        ...buildUserAgentTools({
+          specs: rebuildInput.userTools,
+          pendingToolResults
+        })
+      ],
+      hooks: {
+        afterTool: ({ result }) => {
+          const toolResult = unwrapClineToolResult(result.output);
+          return toolResult == null ? void 0 : { result: toolResult };
+        }
+      },
+      // Built-in tools whose kind requires approval under the session's
+      // permission mode are marked `autoApprove: false`; the runtime then
+      // routes them through `requestToolApproval` below. User tools are
+      // approved by the harness framework, never by the adapter.
+      toolPolicies: Object.fromEntries(
+        activeBuiltinNames.filter(
+          (name) => clineBuiltinToolRequiresApproval({
+            permissionMode,
+            kind: CLINE_NATIVE_TOOL_KINDS[name]
+          })
+        ).map((name) => [name, { autoApprove: false }])
+      ),
+      requestToolApproval: (request) => {
+        if (!isClineBuiltinToolName(request.toolName)) {
+          return { approved: true };
+        }
+        return requestBuiltinToolApproval({
+          toolCallId: request.toolCallId,
+          toolName: request.toolName,
+          input: request.input
+        });
+      },
+      // Mid-turn user messages injected via `submitUserMessage` are consumed
+      // by the runtime between loop iterations, before the next model call.
+      consumePendingUserMessage: () => pendingUserMessages.shift()
+    });
+    agentHasRun = false;
+    unsubscribe = agent.subscribe((event) => {
+      if (!translatorState || !currentEmit) return;
+      for (const part of translateClineEvent(event, translatorState)) {
+        currentEmit(part);
+      }
+    });
+  }
+  function createPromptControl(controlInput) {
+    const abortHandler = () => {
+      settlePendingToolResults("Turn aborted");
+      settlePendingToolApprovals("Turn aborted");
+      agent?.abort("Turn aborted by caller");
+    };
+    if (controlInput.abortSignal) {
+      controlInput.abortSignal.addEventListener("abort", abortHandler, {
+        once: true
+      });
+      void controlInput.done.then(
+        () => {
+          controlInput.abortSignal?.removeEventListener("abort", abortHandler);
+        },
+        () => {
+          controlInput.abortSignal?.removeEventListener("abort", abortHandler);
+        }
+      );
+    }
+    return {
+      async submitToolResult(args) {
+        const pending = pendingToolResults.get(args.toolCallId);
+        if (!pending) return;
+        pendingToolResults.delete(args.toolCallId);
+        pending.resolve(
+          createClineToolResult({
+            output: args.output,
+            isError: args.isError
+          })
+        );
+      },
+      async submitToolApproval(args) {
+        const pending = pendingToolApprovals.get(args.approvalId);
+        if (!pending) return;
+        pendingToolApprovals.delete(args.approvalId);
+        pending.resolve({
+          approved: args.approved,
+          ...args.reason !== void 0 ? { reason: args.reason } : {}
+        });
+      },
+      async submitUserMessage(text) {
+        pendingUserMessages.push(text);
+      },
+      done: controlInput.done
+    };
+  }
+  function runTurn(turnOpts) {
+    if (stopped) {
+      throw new Error("Cline session has been stopped.");
+    }
+    const userTools = turnOpts.tools;
+    const signature = JSON.stringify(userTools.map((t) => t.name).sort());
+    if (agent == null || signature !== lastToolsSignature) {
+      currentMessages = agent?.snapshot().messages ?? currentMessages;
+      rebuildAgent({
+        userTools,
+        ...turnOpts.instructions ? { instructions: turnOpts.instructions } : {}
+      });
+      lastToolsSignature = signature;
+    }
+    currentEmit = turnOpts.emit;
+    translatorState = createClineTranslatorState({
+      builtinToolNames: activeBuiltinNames,
+      hostToolNames: userTools.map((tool2) => tool2.name),
+      mcpToolNames: mcpRuntime.toolNames
+    });
+    turnOpts.emit({
+      type: "stream-start",
+      ...input.settings.modelId ? { modelId: input.settings.modelId } : {}
+    });
+    const turnPromise = (async () => {
+      const runtime = agent;
+      let result;
+      try {
+        result = turnOpts.text === void 0 ? await runtime.continue() : agentHasRun ? await runtime.continue(turnOpts.text) : await runtime.run(turnOpts.text);
+        agentHasRun = true;
+      } catch (error) {
+        if (suspending && isAbortError(error)) return;
+        currentEmit?.({ type: "error", error });
+        return;
+      }
+      currentMessages = result.messages;
+      if (translatorState) {
+        for (const part of finishClineTranslation(translatorState)) {
+          currentEmit?.(part);
+        }
+      }
+      if (result.status === "aborted") {
+        if (suspending) return;
+        currentEmit?.({
+          type: "finish",
+          finishReason: mapRunFinishReason(result.status),
+          totalUsage: usageFromAgentUsage(result.usage)
+        });
+        return;
+      }
+      if (result.status === "failed") {
+        currentEmit?.({
+          type: "error",
+          error: result.error ?? new Error("Cline agent run failed")
+        });
+        return;
+      }
+      currentEmit?.({
+        type: "finish",
+        finishReason: mapRunFinishReason(result.status),
+        totalUsage: usageFromAgentUsage(result.usage)
+      });
+    })();
+    const activeTurnToken = {};
+    const done = turnPromise.finally(() => {
+      if (activeTurn?.token === activeTurnToken) {
+        activeTurn = void 0;
+      }
+      currentEmit = void 0;
+    });
+    activeTurn = {
+      token: activeTurnToken,
+      done
+    };
+    return createPromptControl({
+      done,
+      ...turnOpts.abortSignal ? { abortSignal: turnOpts.abortSignal } : {}
+    });
+  }
+  async function teardown() {
+    unsubscribe?.();
+    unsubscribe = void 0;
+    agent = void 0;
+    await mcpRuntime.dispose();
+  }
+  const doStop = async () => {
+    if (stopped) {
+      throw new Error("Cline session has been stopped.");
+    }
+    stopped = true;
+    parkedClineSessions.delete(input.sessionId);
+    settlePendingToolResults("Cline session stopped");
+    settlePendingToolApprovals("Cline session stopped");
+    try {
+      await persistHistory();
+    } catch {
+    }
+    agent?.abort("Cline session stopped");
+    await teardown();
+    return {
+      type: "resume-session",
+      harnessId: HARNESS_ID2,
+      specificationVersion: "harness-v1",
+      data: { historyFileName: CLINE_DEFAULT_HISTORY_FILE_NAME }
+    };
+  };
+  const sessionImpl = {
+    sessionId: input.sessionId,
+    isResume: input.isResume,
+    ...input.settings.modelId ? { modelId: input.settings.modelId } : {},
+    // The Cline runtime has no bridge to attach to and no in-sandbox event
+    // log to replay; its only cross-process resume path is restoring the
+    // persisted history on a fresh runtime, i.e. `rerun`.
+    doPromptTurn: async (promptOpts) => {
+      return runTurn({
+        text: extractUserText(promptOpts.prompt),
+        tools: promptOpts.tools ?? [],
+        ...promptOpts.instructions ? { instructions: promptOpts.instructions } : {},
+        emit: promptOpts.emit,
+        ...promptOpts.abortSignal ? { abortSignal: promptOpts.abortSignal } : {}
+      });
+    },
+    doContinueTurn: async (continueOpts) => {
+      if (activeTurn != null) {
+        currentEmit = continueOpts.emit;
+        return createPromptControl({
+          done: activeTurn.done,
+          ...continueOpts.abortSignal ? { abortSignal: continueOpts.abortSignal } : {}
+        });
+      }
+      return runTurn({
+        text: void 0,
+        tools: continueOpts.tools ?? [],
+        ...continueOpts.instructions ? { instructions: continueOpts.instructions } : {},
+        emit: continueOpts.emit,
+        ...continueOpts.abortSignal ? { abortSignal: continueOpts.abortSignal } : {}
+      });
+    },
+    doCompact: async () => {
+      throw new HarnessCapabilityUnsupportedError2({
+        message: "cline: manual compaction is not supported by the standalone Cline runtime.",
+        harnessId: HARNESS_ID2
+      });
+    },
+    doDestroy: async () => {
+      if (stopped) return;
+      stopped = true;
+      parkedClineSessions.delete(input.sessionId);
+      settlePendingToolResults("Cline session stopped");
+      settlePendingToolApprovals("Cline session stopped");
+      agent?.abort("Cline session destroyed");
+      await teardown();
+    },
+    doStop,
+    doDetach: async () => {
+      if (activeTurn != null || pendingToolResults.size > 0) {
+        parkedClineSessions.set(input.sessionId, sessionImpl);
+        try {
+          await persistHistory();
+        } catch {
+        }
+        return {
+          type: "resume-session",
+          harnessId: HARNESS_ID2,
+          specificationVersion: "harness-v1",
+          data: { historyFileName: CLINE_DEFAULT_HISTORY_FILE_NAME }
+        };
+      }
+      return doStop();
+    },
+    doSuspendTurn: async () => {
+      if (stopped) {
+        throw new Error("Cline session has been stopped.");
+      }
+      if (activeTurn != null && (pendingToolResults.size > 0 || pendingToolApprovals.size > 0)) {
+        parkedClineSessions.set(input.sessionId, sessionImpl);
+        try {
+          await persistHistory();
+        } catch {
+        }
+        return {
+          type: "continue-turn",
+          harnessId: HARNESS_ID2,
+          specificationVersion: "harness-v1",
+          data: { historyFileName: CLINE_DEFAULT_HISTORY_FILE_NAME }
+        };
+      }
+      suspending = true;
+      agent?.abort("Cline session suspended");
+      if (activeTurn) {
+        await activeTurn.done.catch(() => {
+        });
+      }
+      try {
+        await persistHistory();
+      } catch {
+      }
+      stopped = true;
+      parkedClineSessions.delete(input.sessionId);
+      settlePendingToolResults("Cline session suspended");
+      settlePendingToolApprovals("Cline session suspended");
+      await teardown();
+      return {
+        type: "continue-turn",
+        harnessId: HARNESS_ID2,
+        specificationVersion: "harness-v1",
+        data: { historyFileName: CLINE_DEFAULT_HISTORY_FILE_NAME }
+      };
+    }
+  };
+  return sessionImpl;
+}
+
+// src/version.ts
+var VERSION = true ? "1.0.0" : "0.0.0-test";
+
+// src/cline-harness.ts
+var CLINE_CLIENT_APP = `ai-sdk/harness-cline/${VERSION}`;
+var CLINE_BUILTIN_TOOLS = {
+  read: commonTool("read", {
+    nativeName: "read",
+    toolUseKind: "readonly",
+    description: "Read file contents.",
+    inputSchema: z2.object({
+      file_path: z2.string()
+    })
+  }),
+  write: commonTool("write", {
+    nativeName: "write",
+    toolUseKind: "edit",
+    description: "Overwrite or create a file.",
+    inputSchema: z2.object({
+      file_path: z2.string(),
+      content: z2.string()
+    })
+  }),
+  edit: commonTool("edit", {
+    nativeName: "edit",
+    toolUseKind: "edit",
+    description: "Edit a file by exact string replacement.",
+    inputSchema: z2.object({
+      file_path: z2.string(),
+      old_string: z2.string(),
+      new_string: z2.string()
+    })
+  }),
+  bash: commonTool("bash", {
+    nativeName: "bash",
+    toolUseKind: "bash",
+    description: "Execute a shell command in the sandbox.",
+    inputSchema: z2.object({
+      command: z2.string(),
+      timeout: z2.number().optional()
+    })
+  }),
+  grep: commonTool("grep", {
+    nativeName: "grep",
+    toolUseKind: "readonly",
+    description: "Search file contents with regex.",
+    inputSchema: z2.object({
+      pattern: z2.string(),
+      path: z2.string().optional(),
+      glob: z2.string().optional(),
+      ignoreCase: z2.boolean().optional(),
+      literal: z2.boolean().optional(),
+      context: z2.number().optional(),
+      limit: z2.number().optional()
+    })
+  }),
+  glob: commonTool("glob", {
+    nativeName: "glob",
+    toolUseKind: "readonly",
+    description: "Find files matching a glob pattern.",
+    inputSchema: z2.object({
+      pattern: z2.string(),
+      path: z2.string().optional(),
+      limit: z2.number().optional()
+    })
+  }),
+  ls: {
+    ...tool({
+      description: "List directory entries.",
+      inputSchema: z2.object({
+        path: z2.string().optional(),
+        limit: z2.number().optional()
+      }),
+      outputSchema: z2.unknown()
+    }),
+    nativeName: "ls",
+    toolUseKind: "readonly"
+  }
+};
+function createCline(settings = {}) {
+  return {
+    specificationVersion: "harness-v1",
+    harnessId: "cline",
+    builtinTools: CLINE_BUILTIN_TOOLS,
+    supportsBuiltinToolApprovals: true,
+    supportsBuiltinToolFiltering: true,
+    lifecycleStateSchema: clineResumeStateSchema,
+    doStart: async (startOpts) => {
+      const authEnv = resolveClineEnv({ auth: settings.auth });
+      const lifecycleState = startOpts.continueFrom ?? startOpts.resumeFrom;
+      const resumeData = lifecycleState?.data;
+      return createClineSession({
+        sessionId: startOpts.sessionId,
+        sandboxSession: startOpts.sandboxSession,
+        sessionWorkDir: startOpts.sessionWorkDir,
+        skills: startOpts.skills ?? [],
+        settings: {
+          authEnv,
+          ...settings.mcpServers ? { mcpServers: settings.mcpServers } : {},
+          ...settings.providerId ? { providerId: settings.providerId } : {},
+          ...settings.modelId ? { modelId: settings.modelId } : {},
+          ...settings.apiKey ? { apiKey: settings.apiKey } : {},
+          ...settings.baseUrl ? { baseUrl: settings.baseUrl } : {},
+          ...settings.headers ? { headers: settings.headers } : {},
+          ...settings.reasoningEffort !== void 0 ? { reasoningEffort: settings.reasoningEffort } : {},
+          ...settings.maxIterations !== void 0 ? { maxIterations: settings.maxIterations } : {}
+        },
+        clientApp: CLINE_CLIENT_APP,
+        isResume: lifecycleState != null,
+        ...startOpts.permissionMode ? { permissionMode: startOpts.permissionMode } : {},
+        ...startOpts.builtinToolFiltering ? { builtinToolFiltering: startOpts.builtinToolFiltering } : {},
+        ...resumeData?.historyFileName ? { resumeHistoryFileName: resumeData.historyFileName } : {},
+        ...startOpts.abortSignal ? { abortSignal: startOpts.abortSignal } : {}
+      });
+    }
+  };
+}
+
+// src/index.ts
+var cline = createCline();
+export {
+  VERSION,
+  cline,
+  createCline
+};
+//# sourceMappingURL=index.js.map