@ai-sdk/harness-cline 1.0.27 → 1.0.28

package/dist/index.js

@@ -1,6 +1,7 @@
 // src/cline-harness.ts
 import {
-  commonTool
+  commonTool,
+  HARNESS_V1_BUILTIN_TOOLS
 } from "@ai-sdk/harness";
 import { isHarnessAuthenticationEnvironment as isHarnessAuthenticationEnvironment2 } from "@ai-sdk/harness/utils";
 import { tool } from "@ai-sdk/provider-utils";
@@ -623,6 +624,7 @@ ${description}${skill.content}${files}
 import {
   createTool
 } from "@cline/agents";
+import { createDefaultTools as createDefaultTools2 } from "@cline/core";
 
 // src/cline-utils.ts
 import {
@@ -725,6 +727,7 @@ function usageFromMessageMetrics(metrics) {
 
 // src/cline-tools.ts
 var CLINE_NATIVE_BUILTIN_NAMES = [
+  "ask_question",
   "read",
   "write",
   "edit",
@@ -735,6 +738,7 @@ var CLINE_NATIVE_BUILTIN_NAMES = [
   "skills"
 ];
 var CLINE_NATIVE_TOOL_KINDS = {
+  ask_question: "readonly",
   read: "readonly",
   write: "edit",
   edit: "edit",
@@ -749,15 +753,21 @@ function isClineBuiltinToolName(name) {
 }
 function resolveActiveClineBuiltinNames(toolFiltering) {
   if (toolFiltering == null) return CLINE_NATIVE_BUILTIN_NAMES;
+  const filteredNames = toolFiltering.toolNames.map(
+    (name) => name === "askUserQuestions" ? "ask_question" : name
+  );
   if (toolFiltering.mode === "allow") {
     return CLINE_NATIVE_BUILTIN_NAMES.filter(
-      (name) => toolFiltering.toolNames.includes(name)
+      (name) => filteredNames.includes(name)
     );
   }
   return CLINE_NATIVE_BUILTIN_NAMES.filter(
-    (name) => !toolFiltering.toolNames.includes(name)
+    (name) => !filteredNames.includes(name)
   );
 }
+function clineQuestionKey(input) {
+  return JSON.stringify([input.question, input.options]);
+}
 var clineToolResultMarker = /* @__PURE__ */ Symbol("cline-tool-result");
 function createClineToolResult({
   output,
@@ -791,9 +801,45 @@ async function guarded(run) {
 }
 function buildBuiltinAgentTools({
   ops,
-  activeNames
+  activeNames,
+  pendingQuestions = /* @__PURE__ */ new Map(),
+  pendingQuestionResults = /* @__PURE__ */ new Map()
 }) {
   const tools = {
+    ask_question: createDefaultTools2({
+      executors: {
+        askQuestion: async (question, options, context) => {
+          if (context.toolCallId == null) {
+            throw new Error(
+              "Cline ask_question did not provide a tool call id."
+            );
+          }
+          const questionKey = clineQuestionKey({ question, options });
+          const pendingResult = pendingQuestionResults.get(questionKey);
+          if (pendingResult != null) {
+            pendingQuestionResults.delete(questionKey);
+            return toClineQuestionResult({
+              nativeInput: { question, options },
+              output: pendingResult.output
+            });
+          }
+          return new Promise((resolve) => {
+            pendingQuestions.set(context.toolCallId, {
+              input: { question, options },
+              resolve
+            });
+          });
+        }
+      },
+      enableReadFiles: false,
+      enableSearch: false,
+      enableBash: false,
+      enableWebFetch: false,
+      enableApplyPatch: false,
+      enableEditor: false,
+      enableSkills: false,
+      enableAskQuestion: true
+    }).find((tool2) => tool2.name === "ask_question"),
     read: createTool({
       name: "read",
       description: "Read file contents.",
@@ -948,6 +994,19 @@ function buildBuiltinAgentTools({
   };
   return activeNames.map((name) => tools[name]).filter((tool2) => tool2 != null);
 }
+function toClineQuestionResult(input) {
+  if (input.output.action === "declined" || input.output.action === "cancelled") {
+    return `The user ${input.output.action} the question.`;
+  }
+  const answer = input.output.answers["question-1"];
+  if (answer == null) return "The user did not answer the question.";
+  if (answer.freeform != null) return answer.freeform;
+  const result = answer.optionIds.map((id) => {
+    const index = Number(id.replace(/^option-/, "")) - 1;
+    return input.nativeInput.options[index];
+  }).filter((value) => value != null).join(", ");
+  return result;
+}
 function buildUserAgentTools({
   specs,
   pendingToolResults
@@ -1027,6 +1086,35 @@ function toolCallPart(state, toolCall) {
   if (isMcpTool) {
     state.dynamicToolCallIds.add(toolCall.toolCallId);
   }
+  if (toolCall.toolName === "ask_question") {
+    const nativeInput = toolCall.input;
+    return {
+      type: "tool-call",
+      toolCallId: toolCall.toolCallId,
+      toolName: "askUserQuestions",
+      input: JSON.stringify({
+        allowPartialAnswers: false,
+        questions: [
+          {
+            id: "question-1",
+            question: nativeInput.question,
+            options: nativeInput.options.map((label, index) => ({
+              id: `option-${index + 1}`,
+              label
+            })),
+            allowFreeForm: true
+          }
+        ]
+      }),
+      providerExecuted: false,
+      providerMetadata: {
+        cline: {
+          nativeRequest: nativeInput
+        }
+      },
+      nativeName: "ask_question"
+    };
+  }
   return {
     type: "tool-call",
     toolCallId: toolCall.toolCallId,
@@ -1128,7 +1216,7 @@ function translateClineEvent(event, state) {
         {
           type: "tool-result",
           toolCallId: event.toolCall.toolCallId,
-          toolName: event.toolCall.toolName,
+          toolName: event.toolCall.toolName === "ask_question" ? "askUserQuestions" : event.toolCall.toolName,
           result: toToolResultValue(output),
           ...resultPart?.isError ? { isError: true } : {},
           ...dynamic ? { dynamic: true } : {}
@@ -1309,6 +1397,8 @@ async function createClineSession(input) {
   let acceptingUserMessages = false;
   let currentEmit;
   let translatorState;
+  const pendingQuestions = /* @__PURE__ */ new Map();
+  const pendingQuestionResults = /* @__PURE__ */ new Map();
   let activeTurn;
   function settlePendingToolResults(reason) {
     for (const pending of pendingToolResults.values()) {
@@ -1339,6 +1429,13 @@ async function createClineSession(input) {
     }
     pendingUserMessages.length = 0;
   }
+  function settlePendingQuestions(reason) {
+    for (const pending of pendingQuestions.values()) {
+      pending.resolve(reason);
+    }
+    pendingQuestions.clear();
+    pendingQuestionResults.clear();
+  }
   async function persistHistory() {
     const messages = agent?.snapshot().messages ?? currentMessages;
     await persistHistoryToSandbox({
@@ -1383,7 +1480,12 @@ ${rebuildInput.instructions}` : baseSystemPrompt;
       toolExecution: "parallel",
       ...input.settings.maxIterations !== void 0 ? { maxIterations: input.settings.maxIterations } : {},
       tools: [
-        ...buildBuiltinAgentTools({ ops, activeNames: activeBuiltinNames }),
+        ...buildBuiltinAgentTools({
+          ops,
+          activeNames: activeBuiltinNames,
+          pendingQuestions,
+          pendingQuestionResults
+        }),
         ...rebuildInput.skillsRuntime.tool && activeBuiltinNames.includes("skills") ? [rebuildInput.skillsRuntime.tool] : [],
         ...mcpRuntime.tools,
         ...buildUserAgentTools({
@@ -1452,6 +1554,7 @@ ${rebuildInput.instructions}` : baseSystemPrompt;
     const abortHandler = () => {
       settlePendingToolResults("Turn aborted");
       settlePendingToolApprovals("Turn aborted");
+      settlePendingQuestions("The question was cancelled.");
       agent?.abort("Turn aborted by caller");
     };
     if (controlInput.abortSignal) {
@@ -1469,6 +1572,25 @@ ${rebuildInput.instructions}` : baseSystemPrompt;
     }
     return {
       async submitToolResult(args) {
+        const pendingQuestion = pendingQuestions.get(args.toolCallId);
+        if (pendingQuestion != null) {
+          pendingQuestions.delete(args.toolCallId);
+          pendingQuestion.resolve(
+            toClineQuestionResult({
+              nativeInput: pendingQuestion.input,
+              output: args.output
+            })
+          );
+          return;
+        }
+        if (args.toolResult?.toolName === "askUserQuestions") {
+          const nativeRequest = args.toolResult.providerOptions?.cline?.nativeRequest;
+          if (nativeRequest == null) return;
+          pendingQuestionResults.set(clineQuestionKey(nativeRequest), {
+            output: args.output
+          });
+          return;
+        }
         const pending = pendingToolResults.get(args.toolCallId);
         if (!pending) return;
         pendingToolResults.delete(args.toolCallId);
@@ -1668,6 +1790,7 @@ ${rebuildInput.instructions}` : baseSystemPrompt;
     parkedClineSessions.delete(input.sessionId);
     settlePendingToolResults("Cline session stopped");
     settlePendingToolApprovals("Cline session stopped");
+    settlePendingQuestions("The question was cancelled.");
     try {
       await persistHistory();
     } catch {
@@ -1735,7 +1858,7 @@ ${rebuildInput.instructions}` : baseSystemPrompt;
     },
     doStop,
     doDetach: async () => {
-      if (activeTurn != null || pendingToolResults.size > 0) {
+      if (activeTurn != null || pendingToolResults.size > 0 || pendingQuestions.size > 0) {
         parkedClineSessions.set(input.sessionId, sessionImpl);
         try {
           await persistHistory();
@@ -1754,7 +1877,7 @@ ${rebuildInput.instructions}` : baseSystemPrompt;
       if (stopped) {
         throw new Error("Cline session has been stopped.");
       }
-      if (activeTurn != null && (pendingToolResults.size > 0 || pendingToolApprovals.size > 0)) {
+      if (activeTurn != null && (pendingToolResults.size > 0 || pendingToolApprovals.size > 0 || pendingQuestions.size > 0)) {
         parkedClineSessions.set(input.sessionId, sessionImpl);
         try {
           await persistHistory();
@@ -1794,11 +1917,16 @@ ${rebuildInput.instructions}` : baseSystemPrompt;
 }
 
 // src/version.ts
-var VERSION = true ? "1.0.27" : "0.0.0-test";
+var VERSION = true ? "1.0.28" : "0.0.0-test";
 
 // src/cline-harness.ts
 var CLINE_CLIENT_APP = `ai-sdk/harness-cline/${VERSION}`;
 var CLINE_BUILTIN_TOOLS = {
+  askUserQuestions: {
+    ...HARNESS_V1_BUILTIN_TOOLS.askUserQuestions,
+    nativeName: "ask_question",
+    toolUseKind: "readonly"
+  },
   read: commonTool("read", {
     nativeName: "read",
     toolUseKind: "readonly",