@ai-sdk/harness-cline 1.0.19 → 1.0.20

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @ai-sdk/harness-cline
 
+## 1.0.20
+
+### Patch Changes
+
+- 7608210: feat(harness): add `model` parameter to `HarnessAgent` instead of having each harness adapter support it on their own constructor functions
+- f7bd978: chore(harness): update underlying adapter SDKs to their latest versions
+- 14d4fc0: feat(harness): allow changing harness settings between turns via `prepareCall()` support on `HarnessAgent`
+- 5021768: fix(harness-cline): use native `skills` tool instead of manual file-based workaround
+- Updated dependencies [cc9f6ce]
+- Updated dependencies [7608210]
+- Updated dependencies [6f8a2d7]
+- Updated dependencies [14d4fc0]
+- Updated dependencies [90192f1]
+  - @ai-sdk/harness@1.0.93
+  - @ai-sdk/provider-utils@5.0.33
+
 ## 1.0.19
 
 ### Patch Changes

package/dist/index.d.ts

@@ -26,6 +26,8 @@ type ClineHarnessSettings = {
     /**
      * Model id for the configured provider. When omitted, Cline selects the
      * provider's default model.
+     *
+     * @deprecated Use `model` on `HarnessAgent` instead.
      */
     readonly modelId?: string;
     /**
@@ -80,6 +82,7 @@ declare const CLINE_BUILTIN_TOOLS: {
         limit?: number | undefined;
     }, unknown>;
     readonly ls: HarnessV1BuiltinTool;
+    readonly skills: HarnessV1BuiltinTool;
 };
 declare function createCline(settings?: ClineHarnessSettings): HarnessV1<typeof CLINE_BUILTIN_TOOLS>;
 
@@ -122,6 +125,7 @@ declare const cline: _ai_sdk_harness.HarnessV1<{
         limit?: number | undefined;
     }, unknown>;
     readonly ls: _ai_sdk_harness.HarnessV1BuiltinTool;
+    readonly skills: _ai_sdk_harness.HarnessV1BuiltinTool;
 }>;
 
 export { type ClineAuthenticationMode, type ClineHarnessSettings, VERSION, cline, createCline };

package/dist/index.js

@@ -241,7 +241,6 @@ import { shellQuote } from "@ai-sdk/harness/utils";
 function createClineRemoteOps(options) {
   const { sandbox, workDir } = options;
   const normalizedWorkDir = path2.posix.normalize(workDir);
-  const readableRoots = options.readableRoots?.map((root) => path2.posix.normalize(root.sandboxDir)) ?? [];
   const isInsidePath = ({
     parent,
     candidate
@@ -256,25 +255,10 @@ function createClineRemoteOps(options) {
     }
     return normalized;
   };
-  const assertReadablePath = (inputPath) => {
-    const normalized = path2.posix.normalize(inputPath);
-    if (!isInsidePath({ parent: normalizedWorkDir, candidate: normalized }) && !readableRoots.some(
-      (parent) => isInsidePath({ parent, candidate: normalized })
-    )) {
-      throw new Error(`Cline path escapes the readable roots: ${inputPath}`);
-    }
-    return normalized;
-  };
   const resolvePath = (inputPath) => {
     const resolved = path2.posix.isAbsolute(inputPath) ? path2.posix.normalize(inputPath) : path2.posix.normalize(path2.posix.join(normalizedWorkDir, inputPath));
     return assertWorkspacePath(resolved);
   };
-  const resolveReadablePath = (inputPath) => {
-    if (!path2.posix.isAbsolute(inputPath)) {
-      return resolvePath(inputPath);
-    }
-    return assertReadablePath(inputPath);
-  };
   const runShell = async ({
     command,
     signal
@@ -319,7 +303,7 @@ function createClineRemoteOps(options) {
     remotePath,
     inputPath,
     missingMessage
-  }) => assertReadablePath(
+  }) => assertWorkspacePath(
     await resolveExistingSandboxPath({
       remotePath,
       inputPath,
@@ -352,7 +336,7 @@ function createClineRemoteOps(options) {
     return assertWorkspacePath(resolvedPath);
   };
   const readFile = async (inputPath) => {
-    const remotePath = resolveReadablePath(inputPath);
+    const remotePath = resolvePath(inputPath);
     const resolved = await resolveReadableSandboxPath({
       remotePath,
       inputPath,
@@ -420,7 +404,7 @@ function createClineRemoteOps(options) {
     },
     async grep(pattern, input = {}) {
       const inputPath = input.path ?? ".";
-      const remotePath = resolveReadablePath(inputPath);
+      const remotePath = resolvePath(inputPath);
       const target = await resolveReadableSandboxPath({
         remotePath,
         inputPath
@@ -452,7 +436,7 @@ function createClineRemoteOps(options) {
       return output || "No matches found";
     },
     async glob(pattern, inputPath = ".", limit = 1e3) {
-      const remotePath = resolveReadablePath(inputPath);
+      const remotePath = resolvePath(inputPath);
       const target = await resolveReadableSandboxPath({
         remotePath,
         inputPath
@@ -483,7 +467,7 @@ function createClineRemoteOps(options) {
       ).slice(0, limit);
     },
     async ls(inputPath = ".", limit = 500) {
-      const remotePath = resolveReadablePath(inputPath);
+      const remotePath = resolvePath(inputPath);
       const target = await resolveReadableSandboxPath({
         remotePath,
         inputPath
@@ -516,33 +500,123 @@ function createClineRemoteOps(options) {
 
 // src/cline-skills.ts
 import path3 from "path";
-import { writeSkills } from "@ai-sdk/harness/utils";
-async function writeClineSkills({
-  sandbox,
-  sandboxHomeDir,
-  skills,
-  abortSignal
+import { createDefaultTools } from "@cline/core";
+var CLINE_SKILL_NAME_PATTERN = /^[A-Za-z0-9._-]+$/;
+function createClineSkillsRuntime({
+  skills
 }) {
-  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;
+  const projectedSkills = projectClineSkills({ skills });
+  const signature = JSON.stringify(projectedSkills);
+  if (projectedSkills.length === 0) {
+    return { signature };
+  }
+  const executor = async (...executorArguments) => {
+    const [requestedSkill, args] = executorArguments;
+    const skill = projectedSkills.find(
+      (candidate) => candidate.id === normalizeSkillToken(requestedSkill)
+    );
+    if (skill == null) {
+      const availableSkills = projectedSkills.map((skill2) => skill2.name);
+      return availableSkills.length > 0 ? `Skill "${requestedSkill}" not found. Available skills: ${availableSkills.join(", ")}` : "No skills are currently available.";
+    }
+    return renderSkillInstructions({ skill, args });
+  };
+  executor.configuredSkills = projectedSkills.map((skill) => ({
+    id: skill.id,
+    name: skill.name,
+    description: skill.description,
+    disabled: false
+  }));
+  const tool2 = createDefaultTools({
+    executors: { skills: executor },
+    enableReadFiles: false,
+    enableSearch: false,
+    enableBash: false,
+    enableWebFetch: false,
+    enableApplyPatch: false,
+    enableEditor: false,
+    enableSkills: true,
+    enableAskQuestion: false,
+    enableSubmitAndExit: false
+  }).find((tool3) => tool3.name === "skills");
+  if (tool2 == null) {
+    throw new Error("Cline did not create its native skills tool.");
+  }
+  return { signature, tool: tool2 };
+}
+function projectClineSkills({
+  skills
+}) {
+  const names = /* @__PURE__ */ new Set();
+  const ids = /* @__PURE__ */ new Set();
+  return skills.map((skill) => {
+    if (!CLINE_SKILL_NAME_PATTERN.test(skill.name) || skill.name === "." || skill.name === "..") {
+      throw new Error(`Invalid Cline skill name: ${skill.name}`);
+    }
+    if (names.has(skill.name)) {
+      throw new Error(`Duplicate Cline skill name: ${skill.name}`);
+    }
+    names.add(skill.name);
+    const id = normalizeSkillToken(skill.name);
+    if (ids.has(id)) {
+      throw new Error(`Duplicate Cline skill identifier: ${id}`);
+    }
+    ids.add(id);
+    return {
+      id,
+      name: skill.name,
+      description: skill.description,
+      content: skill.content,
+      files: (skill.files ?? []).map((file) => ({
+        path: normalizeSkillFilePath({
+          skillName: skill.name,
+          filePath: file.path
+        }),
+        content: file.content
+      })).sort(
+        (left, right) => left.path.localeCompare(right.path) || left.content.localeCompare(right.content)
+      )
+    };
+  }).sort((left, right) => left.name.localeCompare(right.name));
+}
+function normalizeSkillToken(skill) {
+  return skill.trim().replace(/^\/+/, "").toLowerCase();
+}
+function normalizeSkillFilePath({
+  skillName,
+  filePath
+}) {
+  const normalized = path3.posix.normalize(filePath);
+  if (normalized === "" || normalized === "." || normalized.startsWith("../") || normalized.includes("/../") || normalized.endsWith("/..") || path3.posix.isAbsolute(normalized)) {
+    throw new Error(
+      `Invalid Cline skill file path for ${skillName}: ${filePath}`
+    );
+  }
+  return normalized;
 }
-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;
+function renderSkillInstructions({
+  skill,
+  args
+}) {
+  const trimmedArgs = args?.trim();
+  const argsTag = trimmedArgs ? `
+<command-args>${trimmedArgs}</command-args>` : "";
+  const description = skill.description.trim() ? `Description: ${skill.description.trim()}
+
+` : "";
+  const files = skill.files.length === 0 ? "" : `
+
+<skill-files>
+${skill.files.map(
+    (file) => `<skill-file path=${JSON.stringify(file.path)}>
+${file.content}
+</skill-file>`
+  ).join("\n")}
+</skill-files>`;
+  return `<command-name>${skill.name}</command-name>${argsTag}
+<command-instructions>
+${description}${skill.content}${files}
+</command-instructions>`;
 }
 
 // src/cline-tools.ts
@@ -657,7 +731,8 @@ var CLINE_NATIVE_BUILTIN_NAMES = [
   "bash",
   "grep",
   "glob",
-  "ls"
+  "ls",
+  "skills"
 ];
 var CLINE_NATIVE_TOOL_KINDS = {
   read: "readonly",
@@ -666,7 +741,8 @@ var CLINE_NATIVE_TOOL_KINDS = {
   bash: "bash",
   grep: "readonly",
   glob: "readonly",
-  ls: "readonly"
+  ls: "readonly",
+  skills: "readonly"
 };
 function isClineBuiltinToolName(name) {
   return CLINE_NATIVE_BUILTIN_NAMES.includes(name);
@@ -1110,7 +1186,7 @@ function clineBuiltinToolRequiresApproval(input) {
   return input.kind === "edit" || input.kind === "bash";
 }
 function buildSystemPrompt(input) {
-  const sections = [
+  return [
     "You are Cline, an autonomous coding agent operating inside a sandboxed workspace.",
     `## Workspace
 
@@ -1118,11 +1194,7 @@ The workspace root is \`${input.sessionWorkDir}\`. All relative file paths and s
     `## Sandbox
 
 ${input.sandboxDescription}`
-  ];
-  if (input.skillsSection) {
-    sections.push(input.skillsSection);
-  }
-  return sections.join("\n\n");
+  ].join("\n\n");
 }
 function toClineBackendProviderBaseUrl(baseUrl) {
   return `${baseUrl.replace(/\/+$/, "")}/api/v1`;
@@ -1199,28 +1271,9 @@ async function createClineSession(input) {
   const activeBuiltinNames = resolveActiveClineBuiltinNames(
     input.builtinToolFiltering
   );
-  let skillsSection;
-  let skillRootDir;
-  if (input.skills.length > 0) {
-    skillRootDir = await writeClineSkills({
-      sandbox: toolSafeSandboxSession,
-      sandboxHomeDir,
-      skills: input.skills,
-      ...input.abortSignal ? { abortSignal: input.abortSignal } : {}
-    });
-    if (skillRootDir) {
-      skillsSection = renderSkillsPromptSection(input.skills, skillRootDir);
-    }
-  }
   const ops = createClineRemoteOps({
     sandbox: toolSafeSandboxSession,
-    workDir: input.sessionWorkDir,
-    ...skillRootDir ? { readableRoots: [{ sandboxDir: skillRootDir }] } : {}
-  });
-  const baseSystemPrompt = buildSystemPrompt({
-    sessionWorkDir: input.sessionWorkDir,
-    sandboxDescription: toolSafeSandboxSession.description,
-    ...skillsSection ? { skillsSection } : {}
+    workDir: input.sessionWorkDir
   });
   let currentMessages = [];
   if (input.isResume && input.resumeHistoryFileName) {
@@ -1243,7 +1296,7 @@ async function createClineSession(input) {
   });
   let agent;
   let unsubscribe;
-  let lastToolsSignature;
+  let lastAgentConfigurationSignature;
   let agentHasRun = false;
   let stopped = false;
   let suspending = false;
@@ -1314,14 +1367,21 @@ async function createClineSession(input) {
         }
       } : {},
       sessionId: input.sessionId,
-      systemPrompt: rebuildInput.instructions ? `${baseSystemPrompt}
+      systemPrompt: (() => {
+        const baseSystemPrompt = buildSystemPrompt({
+          sessionWorkDir: input.sessionWorkDir,
+          sandboxDescription: toolSafeSandboxSession.description
+        });
+        return rebuildInput.instructions ? `${baseSystemPrompt}
 
-${rebuildInput.instructions}` : baseSystemPrompt,
+${rebuildInput.instructions}` : baseSystemPrompt;
+      })(),
       initialMessages: currentMessages,
       toolExecution: "parallel",
       ...input.settings.maxIterations !== void 0 ? { maxIterations: input.settings.maxIterations } : {},
       tools: [
         ...buildBuiltinAgentTools({ ops, activeNames: activeBuiltinNames }),
+        ...rebuildInput.skillsRuntime.tool && activeBuiltinNames.includes("skills") ? [rebuildInput.skillsRuntime.tool] : [],
         ...mcpRuntime.tools,
         ...buildUserAgentTools({
           specs: rebuildInput.userTools,
@@ -1438,11 +1498,14 @@ ${rebuildInput.instructions}` : baseSystemPrompt,
       done: controlInput.done
     };
   }
-  function runTurn(turnOpts) {
+  async function runTurn(turnOpts) {
     if (stopped) {
       throw new Error("Cline session has been stopped.");
     }
     const userTools = turnOpts.tools;
+    const skillsRuntime = createClineSkillsRuntime({
+      skills: turnOpts.skills
+    });
     if (turnOpts.responseFormat?.type === "json" && turnOpts.responseFormat.schema == null) {
       throw new HarnessCapabilityUnsupportedError2({
         message: "Harness 'cline' requires a JSON schema for structured output.",
@@ -1456,22 +1519,28 @@ ${rebuildInput.instructions}` : baseSystemPrompt,
       });
     }
     const signature = JSON.stringify({
-      tools: userTools.map((t) => t.name).sort(),
-      responseFormat: turnOpts.responseFormat
+      tools: userTools,
+      responseFormat: turnOpts.responseFormat,
+      instructions: turnOpts.instructions,
+      skills: skillsRuntime.signature
     });
-    if (agent == null || signature !== lastToolsSignature) {
+    if (agent == null || signature !== lastAgentConfigurationSignature) {
       currentMessages = agent?.snapshot().messages ?? currentMessages;
       rebuildAgent({
         userTools,
+        skillsRuntime,
         responseFormat: turnOpts.responseFormat,
         ...turnOpts.instructions ? { instructions: turnOpts.instructions } : {}
       });
-      lastToolsSignature = signature;
+      lastAgentConfigurationSignature = signature;
     }
     currentEmit = turnOpts.emit;
+    const userToolNames = new Set(userTools.map((tool2) => tool2.name));
     translatorState = createClineTranslatorState({
-      builtinToolNames: activeBuiltinNames,
-      hostToolNames: userTools.map((tool2) => tool2.name),
+      builtinToolNames: activeBuiltinNames.filter(
+        (name) => !userToolNames.has(name)
+      ),
+      hostToolNames: userToolNames,
       ignoredToolNames: turnOpts.responseFormat?.type === "json" ? ["structured_output"] : [],
       mcpToolNames: mcpRuntime.toolNames
     });
@@ -1610,6 +1679,7 @@ ${rebuildInput.instructions}` : baseSystemPrompt,
     doPromptTurn: async (promptOpts) => {
       return runTurn({
         text: extractUserText(promptOpts.prompt),
+        skills: promptOpts.skills,
         tools: promptOpts.tools ?? [],
         ...promptOpts.instructions ? { instructions: promptOpts.instructions } : {},
         emit: promptOpts.emit,
@@ -1627,6 +1697,7 @@ ${rebuildInput.instructions}` : baseSystemPrompt,
       }
       return runTurn({
         text: void 0,
+        skills: continueOpts.skills,
         tools: continueOpts.tools ?? [],
         ...continueOpts.instructions ? { instructions: continueOpts.instructions } : {},
         emit: continueOpts.emit,
@@ -1710,7 +1781,7 @@ ${rebuildInput.instructions}` : baseSystemPrompt,
 }
 
 // src/version.ts
-var VERSION = true ? "1.0.19" : "0.0.0-test";
+var VERSION = true ? "1.0.20" : "0.0.0-test";
 
 // src/cline-harness.ts
 var CLINE_CLIENT_APP = `ai-sdk/harness-cline/${VERSION}`;
@@ -1786,6 +1857,18 @@ var CLINE_BUILTIN_TOOLS = {
     }),
     nativeName: "ls",
     toolUseKind: "readonly"
+  },
+  skills: {
+    ...tool({
+      description: "Execute a configured skill by name.",
+      inputSchema: z2.object({
+        skill: z2.string(),
+        args: z2.string().optional()
+      }),
+      outputSchema: z2.string()
+    }),
+    nativeName: "skills",
+    toolUseKind: "readonly"
   }
 };
 function createCline(settings = {}) {
@@ -1797,6 +1880,7 @@ function createCline(settings = {}) {
     supportsBuiltinToolFiltering: true,
     lifecycleStateSchema: clineResumeStateSchema,
     doStart: async (startOpts) => {
+      const modelId = startOpts.model ?? settings.modelId;
       const authEnv = resolveClineEnv({ auth: settings.auth });
       const lifecycleState = startOpts.continueFrom ?? startOpts.resumeFrom;
       const resumeData = lifecycleState?.data;
@@ -1804,13 +1888,12 @@ function createCline(settings = {}) {
         sessionId: startOpts.sessionId,
         sandboxSession: startOpts.sandboxSession,
         sessionWorkDir: startOpts.sessionWorkDir,
-        skills: startOpts.skills ?? [],
         settings: {
           authEnv,
           isAuthenticationEnvironmentOverride: isHarnessAuthenticationEnvironment2(settings.auth),
           ...settings.mcpServers ? { mcpServers: settings.mcpServers } : {},
           ...settings.providerId ? { providerId: settings.providerId } : {},
-          ...settings.modelId ? { modelId: settings.modelId } : {},
+          ...modelId == null ? {} : { modelId },
           ...settings.apiKey ? { apiKey: settings.apiKey } : {},
           ...settings.baseUrl ? { baseUrl: settings.baseUrl } : {},
           ...settings.headers ? { headers: settings.headers } : {},