@ai-sdk/harness-cline 1.0.27 → 1.0.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/harness-cline",
-  "version": "1.0.27",
+  "version": "1.0.29",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -26,7 +26,7 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/harness": "1.0.100",
+    "@ai-sdk/harness": "1.0.102",
     "@ai-sdk/provider": "4.0.10",
     "@ai-sdk/provider-utils": "5.0.36",
     "@cline/agents": "^0.0.79",

package/src/cline-harness.ts

@@ -1,5 +1,6 @@
 import {
   commonTool,
+  HARNESS_V1_BUILTIN_TOOLS,
   type HarnessV1,
   type HarnessV1BuiltinTool,
 } from '@ai-sdk/harness';
@@ -70,6 +71,11 @@ export type ClineHarnessSettings = {
  * `cline-tools.ts` — keep the two in sync.
  */
 const CLINE_BUILTIN_TOOLS = {
+  askUserQuestions: {
+    ...HARNESS_V1_BUILTIN_TOOLS.askUserQuestions,
+    nativeName: 'ask_question',
+    toolUseKind: 'readonly',
+  },
   read: commonTool('read', {
     nativeName: 'read',
     toolUseKind: 'readonly',
@@ -187,6 +193,7 @@ export function createCline(
           ...(settings.apiKey ? { apiKey: settings.apiKey } : {}),
           ...(settings.baseUrl ? { baseUrl: settings.baseUrl } : {}),
           ...(settings.headers ? { headers: settings.headers } : {}),
+          ...(startOpts.headers ? { agentHeaders: startOpts.headers } : {}),
           ...(settings.reasoningEffort !== undefined
             ? { reasoningEffort: settings.reasoningEffort }
             : {}),

package/src/cline-session.ts

@@ -7,6 +7,7 @@ import {
   type HarnessV1PermissionMode,
   type HarnessV1PromptControl,
   type HarnessV1PromptTurnOptions,
+  type HarnessV1QuestionsToolOutput,
   type HarnessV1ResumeSessionState,
   type HarnessV1Session,
   type HarnessV1Skill,
@@ -45,8 +46,12 @@ import {
   CLINE_NATIVE_TOOL_KINDS,
   createClineToolResult,
   isClineBuiltinToolName,
+  clineQuestionKey,
   resolveActiveClineBuiltinNames,
   type PendingToolResult,
+  type PendingClineQuestion,
+  type PendingClineQuestionResult,
+  toClineQuestionResult,
   unwrapClineToolResult,
 } from './cline-tools';
 import {
@@ -92,6 +97,7 @@ export interface ClineSessionSettings {
   readonly apiKey?: string;
   readonly baseUrl?: string;
   readonly headers?: Record<string, string>;
+  readonly agentHeaders?: Readonly<Record<string, string>>;
   readonly reasoningEffort?: ClineReasoningEffort;
   readonly maxIterations?: number;
 }
@@ -198,10 +204,16 @@ function createClineAgentModel({
   const headers = isAiGateway
     ? {
         ...settings.headers,
+        ...settings.agentHeaders,
         'User-Agent': clientApp,
         'x-client-app': clientApp,
       }
-    : settings.headers;
+    : settings.headers != null || settings.agentHeaders != null
+      ? {
+          ...settings.headers,
+          ...settings.agentHeaders,
+        }
+      : undefined;
   const gateway = Llms.createGateway({
     providerConfigs: [
       {
@@ -320,6 +332,8 @@ export async function createClineSession(
   // Emit channel set at the start of every turn and cleared on end.
   let currentEmit: ((part: HarnessV1StreamPart) => void) | undefined;
   let translatorState: ClineTranslatorState | undefined;
+  const pendingQuestions = new Map<string, PendingClineQuestion>();
+  const pendingQuestionResults = new Map<string, PendingClineQuestionResult>();
   let activeTurn: ActiveClineTurn | undefined;
 
   function settlePendingToolResults(reason: string): void {
@@ -355,6 +369,14 @@ export async function createClineSession(
     pendingUserMessages.length = 0;
   }
 
+  function settlePendingQuestions(reason: string): void {
+    for (const pending of pendingQuestions.values()) {
+      pending.resolve(reason);
+    }
+    pendingQuestions.clear();
+    pendingQuestionResults.clear();
+  }
+
   async function persistHistory(): Promise<void> {
     const messages = agent?.snapshot().messages ?? currentMessages;
     await persistHistoryToSandbox({
@@ -414,7 +436,12 @@ export async function createClineSession(
         ? { maxIterations: input.settings.maxIterations }
         : {}),
       tools: [
-        ...buildBuiltinAgentTools({ ops, activeNames: activeBuiltinNames }),
+        ...buildBuiltinAgentTools({
+          ops,
+          activeNames: activeBuiltinNames,
+          pendingQuestions,
+          pendingQuestionResults,
+        }),
         ...(rebuildInput.skillsRuntime.tool &&
         activeBuiltinNames.includes('skills')
           ? [rebuildInput.skillsRuntime.tool]
@@ -505,6 +532,7 @@ export async function createClineSession(
       // executions do not dangle, then abort the loop itself.
       settlePendingToolResults('Turn aborted');
       settlePendingToolApprovals('Turn aborted');
+      settlePendingQuestions('The question was cancelled.');
       agent?.abort('Turn aborted by caller');
     };
     if (controlInput.abortSignal) {
@@ -523,6 +551,26 @@ export async function createClineSession(
 
     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 as HarnessV1QuestionsToolOutput,
+            }),
+          );
+          return;
+        }
+        if (args.toolResult?.toolName === 'askUserQuestions') {
+          const nativeRequest = args.toolResult.providerOptions?.cline
+            ?.nativeRequest as PendingClineQuestion['input'] | undefined;
+          if (nativeRequest == null) return;
+          pendingQuestionResults.set(clineQuestionKey(nativeRequest), {
+            output: args.output as HarnessV1QuestionsToolOutput,
+          });
+          return;
+        }
         const pending = pendingToolResults.get(args.toolCallId);
         if (!pending) return;
         pendingToolResults.delete(args.toolCallId);
@@ -784,6 +832,7 @@ export async function createClineSession(
     parkedClineSessions.delete(input.sessionId);
     settlePendingToolResults('Cline session stopped');
     settlePendingToolApprovals('Cline session stopped');
+    settlePendingQuestions('The question was cancelled.');
 
     // Persist the conversation into the sandbox so a future process can pick
     // it up after the sandbox provider reattaches.
@@ -889,7 +938,11 @@ export async function createClineSession(
     doStop,
 
     doDetach: async (): Promise<HarnessV1ResumeSessionState> => {
-      if (activeTurn != null || pendingToolResults.size > 0) {
+      if (
+        activeTurn != null ||
+        pendingToolResults.size > 0 ||
+        pendingQuestions.size > 0
+      ) {
         parkedClineSessions.set(input.sessionId, sessionImpl);
         try {
           await persistHistory();
@@ -916,7 +969,9 @@ export async function createClineSession(
       }
       if (
         activeTurn != null &&
-        (pendingToolResults.size > 0 || pendingToolApprovals.size > 0)
+        (pendingToolResults.size > 0 ||
+          pendingToolApprovals.size > 0 ||
+          pendingQuestions.size > 0)
       ) {
         parkedClineSessions.set(input.sessionId, sessionImpl);
         try {

package/src/cline-tools.ts

@@ -1,5 +1,6 @@
 import type {
   HarnessV1BuiltinToolFiltering,
+  HarnessV1QuestionsToolOutput,
   HarnessV1ToolSpec,
 } from '@ai-sdk/harness';
 import {
@@ -7,6 +8,7 @@ import {
   type AgentTool,
   type AgentToolResult,
 } from '@cline/agents';
+import { createDefaultTools } from '@cline/core';
 import type { ClineRemoteOps } from './cline-remote-ops';
 import { getErrorText } from './cline-utils';
 
@@ -17,6 +19,7 @@ import { getErrorText } from './cline-utils';
  * identical.
  */
 export const CLINE_NATIVE_BUILTIN_NAMES = [
+  'ask_question',
   'read',
   'write',
   'edit',
@@ -33,6 +36,7 @@ export type ClineNativeBuiltinName =
 export const CLINE_NATIVE_TOOL_KINDS: Readonly<
   Record<ClineNativeBuiltinName, 'readonly' | 'edit' | 'bash'>
 > = {
+  ask_question: 'readonly',
   read: 'readonly',
   write: 'edit',
   edit: 'edit',
@@ -58,13 +62,16 @@ export function resolveActiveClineBuiltinNames(
   toolFiltering: HarnessV1BuiltinToolFiltering | undefined,
 ): ReadonlyArray<ClineNativeBuiltinName> {
   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),
+      filteredNames.includes(name),
     );
   }
   return CLINE_NATIVE_BUILTIN_NAMES.filter(
-    name => !toolFiltering.toolNames.includes(name),
+    name => !filteredNames.includes(name),
   );
 }
 
@@ -72,6 +79,25 @@ export interface PendingToolResult {
   resolve: (value: unknown) => void;
 }
 
+export interface PendingClineQuestion {
+  readonly input: {
+    readonly question: string;
+    readonly options: readonly string[];
+  };
+  resolve: (value: string) => void;
+}
+
+export interface PendingClineQuestionResult {
+  readonly output: HarnessV1QuestionsToolOutput;
+}
+
+export function clineQuestionKey(input: {
+  readonly question: string;
+  readonly options: readonly string[];
+}): string {
+  return JSON.stringify([input.question, input.options]);
+}
+
 const clineToolResultMarker = Symbol('cline-tool-result');
 
 interface ClineToolResult {
@@ -136,12 +162,50 @@ async function guarded<T>(run: () => Promise<T>): Promise<ClineToolResult> {
 export function buildBuiltinAgentTools({
   ops,
   activeNames,
+  pendingQuestions = new Map(),
+  pendingQuestionResults = new Map(),
 }: {
   ops: ClineRemoteOps;
   activeNames: ReadonlyArray<ClineNativeBuiltinName>;
+  pendingQuestions?: Map<string, PendingClineQuestion>;
+  pendingQuestionResults?: Map<string, PendingClineQuestionResult>;
 }): AgentTool<any, any>[] {
   // biome/eslint: `any` matches the runtime's own `tools?: readonly AgentTool<any, any>[]`.
   const tools: Partial<Record<ClineNativeBuiltinName, AgentTool<any, any>>> = {
+    ask_question: createDefaultTools({
+      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<string>(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(tool => tool.name === 'ask_question'),
     read: createTool({
       name: 'read',
       description: 'Read file contents.',
@@ -325,6 +389,29 @@ export function buildBuiltinAgentTools({
     .filter((tool): tool is AgentTool<any, any> => tool != null);
 }
 
+export function toClineQuestionResult(input: {
+  nativeInput: PendingClineQuestion['input'];
+  output: HarnessV1QuestionsToolOutput;
+}): string {
+  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 is string => value != null)
+    .join(', ');
+  return result;
+}
+
 /**
  * Build host-executed user tools. When the model calls one, the tool parks a
  * promise keyed by the runtime's `toolCallId`; the harness caller supplies the

package/src/cline-translate.ts

@@ -78,6 +78,38 @@ function toolCallPart(
   if (isMcpTool) {
     state.dynamicToolCallIds.add(toolCall.toolCallId);
   }
+  if (toolCall.toolName === 'ask_question') {
+    const nativeInput = toolCall.input as {
+      question: string;
+      options: string[];
+    };
+    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,
@@ -209,7 +241,10 @@ export function translateClineEvent(
         {
           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 } : {}),