@aion0/forge 0.9.12 → 0.9.14

package/lib/chat/llm/anthropic.ts

@@ -1,64 +1,36 @@
 /**
- * Anthropic adapter — ported from the extension. Server-side variant
- * (no dangerouslyAllowBrowser). OAuth tokens (sk-ant-oat-*) get the
- * special beta header + authToken handling.
+ * Anthropic adapter — uses Vercel AI SDK (@ai-sdk/anthropic + ai).
+ * Public contract (streamLlm interface) is unchanged from the hand-rolled
+ * version this replaced; agent-loop.ts callers see no difference.
+ *
+ * Forge-specific bits we keep:
+ *  - OAuth token (sk-ant-oat-*) → Authorization: Bearer + oauth beta header
+ *  - Connector tool names (dotted, e.g. "gitlab.list_my_mrs") encoded as
+ *    "__" to satisfy Anthropic's name regex; decoded on tool_use events
  */
 
 import Anthropic from '@anthropic-ai/sdk';
-import type { Message } from '../types';
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { jsonSchema, streamText, type ModelMessage } from 'ai';
+import type { ContentBlock, Message } from '../types';
 import type { LlmAdapter, LlmCallbacks, LlmRequest, LlmTurnResult, StopReason } from './types';
 
-function historyToApi(history: Message[]): Anthropic.MessageParam[] {
-  const out: Anthropic.MessageParam[] = [];
-  for (const m of history) {
-    const content: Anthropic.ContentBlockParam[] = [];
-    for (const b of m.blocks) {
-      if (b.type === 'text') {
-        if (b.text.length > 0) content.push({ type: 'text', text: b.text });
-      } else if (b.type === 'tool_use') {
-        // Same encoding as tool definitions — names with `.` must
-        // round-trip through Anthropic as `__` to satisfy its tool name
-        // regex when this turn's history is re-sent next turn.
-        content.push({
-          type: 'tool_use',
-          id: b.id,
-          name: b.name.replace(/\./g, '__'),
-          input: (b.input ?? {}) as Record<string, unknown>,
-        });
-      } else if (b.type === 'tool_result') {
-        content.push({
-          type: 'tool_result',
-          tool_use_id: b.tool_use_id,
-          content: b.content,
-          is_error: b.is_error,
-        });
-      }
-    }
-    if (content.length === 0) continue;
-    out.push({ role: m.role, content });
-  }
-  return out;
-}
-
-function mapStop(r: Anthropic.Message['stop_reason']): StopReason {
-  switch (r) {
-    case 'end_turn': return 'end_turn';
-    case 'tool_use': return 'tool_use';
-    case 'max_tokens': return 'max_tokens';
-    case 'refusal': return 'refusal';
-    default: return 'other';
-  }
-}
-
 function isOauthToken(key: string): boolean {
   return key.startsWith('sk-ant-oat');
 }
 
+/**
+ * Raw Anthropic SDK client (one-shot calls, non-streaming). Used by
+ * /api/schedules/extract for structured JSON extraction. Kept here so OAuth
+ * + baseURL handling matches the streaming adapter; callers wanting tool
+ * calls / streaming should use streamLlm via the Vercel AI SDK adapter below.
+ */
 export function makeAnthropicClient(apiKey: string, baseUrl: string): Anthropic {
+  const oauth = isOauthToken(apiKey);
   const opts: ConstructorParameters<typeof Anthropic>[0] = {
     baseURL: baseUrl || undefined,
   };
-  if (isOauthToken(apiKey)) {
+  if (oauth) {
     opts.authToken = apiKey;
     opts.defaultHeaders = { 'anthropic-beta': 'oauth-2025-04-20' };
   } else {
@@ -69,49 +41,127 @@ export function makeAnthropicClient(apiKey: string, baseUrl: string): Anthropic
 
 /**
  * Anthropic restricts tool names to `^[a-zA-Z0-9_-]{1,128}$`. Forge's
- * connector tools use a `connector.tool` namespace (e.g.
- * `gitlab.list_my_mrs`), so we encode the dot as `__` on the way out and
- * decode it back when Anthropic returns a tool_use. Internal dispatcher
- * still sees the canonical dotted form.
+ * connector tools use a `connector.tool` namespace, so we encode the
+ * dot as `__` on the way out and decode it back on tool_use. Internal
+ * dispatcher still sees the canonical dotted form.
  */
-function encodeToolName(name: string): string {
-  return name.replace(/\./g, '__');
+function encodeToolName(name: string): string { return name.replace(/\./g, '__'); }
+function decodeToolName(name: string): string { return name.replace(/__/g, '.'); }
+
+function makeClient(apiKey: string, baseUrl: string) {
+  const oauth = isOauthToken(apiKey);
+  return createAnthropic({
+    apiKey: oauth ? '' : apiKey,
+    baseURL: baseUrl || undefined,
+    headers: oauth
+      ? {
+          authorization: `Bearer ${apiKey}`,
+          'anthropic-beta': 'oauth-2025-04-20',
+        }
+      : undefined,
+  });
 }
-function decodeToolName(name: string): string {
-  return name.replace(/__/g, '.');
+
+/** Convert Forge Message[] → AI SDK ModelMessage[]. */
+function historyToModelMessages(history: Message[]): ModelMessage[] {
+  const out: ModelMessage[] = [];
+  for (const m of history) {
+    if (m.role === 'user') {
+      // User message may carry plain text OR tool_result blocks.
+      const toolResults = m.blocks.filter((b): b is Extract<ContentBlock, { type: 'tool_result' }> => b.type === 'tool_result');
+      if (toolResults.length > 0) {
+        out.push({
+          role: 'tool',
+          content: toolResults.map((r) => ({
+            type: 'tool-result' as const,
+            toolCallId: r.tool_use_id,
+            toolName: '', // tool name not tracked in our model; SDK ignores when matching by toolCallId
+            output: { type: 'text', value: r.content },
+          })),
+        });
+        continue;
+      }
+      const text = m.blocks
+        .filter((b): b is Extract<ContentBlock, { type: 'text' }> => b.type === 'text')
+        .map((b) => b.text).join('\n');
+      if (text.length > 0) out.push({ role: 'user', content: text });
+    } else {
+      // Assistant: text + tool_use blocks
+      const parts: any[] = [];
+      for (const b of m.blocks) {
+        if (b.type === 'text' && b.text.length > 0) {
+          parts.push({ type: 'text', text: b.text });
+        } else if (b.type === 'tool_use') {
+          parts.push({
+            type: 'tool-call',
+            toolCallId: b.id,
+            toolName: encodeToolName(b.name),
+            input: b.input ?? {},
+          });
+        }
+      }
+      if (parts.length > 0) out.push({ role: 'assistant', content: parts });
+    }
+  }
+  return out;
+}
+
+function mapStop(r: string | undefined): StopReason {
+  switch (r) {
+    case 'stop': return 'end_turn';
+    case 'tool-calls': return 'tool_use';
+    case 'length': return 'max_tokens';
+    case 'content-filter': return 'refusal';
+    case 'error': return 'error';
+    default: return 'other';
+  }
 }
 
 export const anthropicAdapter: LlmAdapter = {
   async stream(req: LlmRequest, cb: LlmCallbacks): Promise<LlmTurnResult> {
-    const client = makeAnthropicClient(req.apiKey, req.baseUrl);
+    const client = makeClient(req.apiKey, req.baseUrl);
 
-    const stream = client.messages.stream({
-      model: req.model,
-      max_tokens: req.maxTokens,
-      system: req.system,
-      tools: req.tools.map((t) => ({
-        name: encodeToolName(t.name),
+    // Build tool set as Record<encoded_name, ToolDef>. We DO NOT supply
+    // execute — chat owns dispatch (destructive confirm, browser bridge,
+    // memory tools etc all live in agent-loop). Setting stopWhen with
+    // stepCountIs(1) prevents the SDK from auto-rolling a second step.
+    const tools: Record<string, any> = {};
+    for (const t of req.tools) {
+      tools[encodeToolName(t.name)] = {
         description: t.description,
-        input_schema: t.input_schema as Anthropic.Tool.InputSchema,
-      })),
-      messages: historyToApi(req.history),
-    });
-
-    stream.on('text', (delta: string) => cb.onTextDelta(delta));
+        inputSchema: jsonSchema(t.input_schema),
+      };
+    }
 
-    const final = await stream.finalMessage();
+    const result = streamText({
+      model: client(req.model),
+      system: req.system,
+      messages: historyToModelMessages(req.history),
+      tools,
+      maxOutputTokens: req.maxTokens,
+    });
 
-    const content: LlmTurnResult['content'] = [];
-    for (const block of final.content) {
-      if (block.type === 'text') {
-        content.push({ type: 'text', text: block.text });
-      } else if (block.type === 'tool_use') {
-        const decodedName = decodeToolName(block.name);
-        cb.onToolUse({ id: block.id, name: decodedName, input: block.input });
-        content.push({ type: 'tool_use', id: block.id, name: decodedName, input: block.input });
+    const content: ContentBlock[] = [];
+    let textBuf = '';
+    for await (const part of result.fullStream) {
+      if (part.type === 'text-delta') {
+        textBuf += part.text;
+        cb.onTextDelta(part.text);
+      } else if (part.type === 'tool-call') {
+        if (textBuf.length > 0) {
+          content.push({ type: 'text', text: textBuf });
+          textBuf = '';
+        }
+        const decoded = decodeToolName(part.toolName);
+        cb.onToolUse({ id: part.toolCallId, name: decoded, input: part.input });
+        content.push({ type: 'tool_use', id: part.toolCallId, name: decoded, input: part.input });
+      } else if (part.type === 'error') {
+        throw new Error(`Anthropic stream error: ${String((part as any).error)}`);
       }
     }
+    if (textBuf.length > 0) content.push({ type: 'text', text: textBuf });
 
-    return { stopReason: mapStop(final.stop_reason), content };
+    const finishReason = await result.finishReason;
+    return { stopReason: mapStop(finishReason), content };
   },
 };

package/lib/chat/llm/openai.ts

@@ -1,215 +1,110 @@
+/**
+ * OpenAI-compatible adapter — uses Vercel AI SDK (@ai-sdk/openai + ai).
+ * Public contract unchanged from the hand-rolled version; works with any
+ * OpenAI-compat endpoint (api.openai.com, DeepSeek, OpenRouter, Anyscale,
+ * vLLM, Ollama-OpenAI shim, etc.) via the baseUrl override.
+ */
+
+import { createOpenAI } from '@ai-sdk/openai';
+import { jsonSchema, streamText, type ModelMessage } from 'ai';
 import type { ContentBlock, Message } from '../types';
 import type { LlmAdapter, LlmCallbacks, LlmRequest, LlmTurnResult, StopReason } from './types';
 
-// Minimal OpenAI-compatible Chat Completions types — covers what we use.
-interface OAIToolCall {
-  index?: number;
-  id?: string;
-  type?: 'function';
-  function?: { name?: string; arguments?: string };
-}
-
-interface OAITool {
-  type: 'function';
-  function: {
-    name: string;
-    description: string;
-    parameters: Record<string, unknown>;
-  };
-}
-
-type OAIMessage =
-  | { role: 'system'; content: string }
-  | { role: 'user'; content: string }
-  | { role: 'assistant'; content: string | null; tool_calls?: { id: string; type: 'function'; function: { name: string; arguments: string } }[] }
-  | { role: 'tool'; tool_call_id: string; content: string };
-
-interface OAIChunk {
-  choices?: {
-    index?: number;
-    delta?: {
-      role?: string;
-      content?: string | null;
-      tool_calls?: OAIToolCall[];
-    };
-    finish_reason?: string | null;
-  }[];
-}
-
-function defaultBase(baseUrl: string): string {
-  return (baseUrl || 'https://api.openai.com/v1').replace(/\/+$/, '');
-}
-
-function historyToApi(history: Message[]): OAIMessage[] {
-  const out: OAIMessage[] = [];
+function historyToModelMessages(history: Message[]): ModelMessage[] {
+  const out: ModelMessage[] = [];
   for (const m of history) {
     if (m.role === 'user') {
-      // A user message in our model can be plain text OR a vehicle for tool_result blocks.
       const toolResults = m.blocks.filter((b): b is Extract<ContentBlock, { type: 'tool_result' }> => b.type === 'tool_result');
       if (toolResults.length > 0) {
-        for (const r of toolResults) {
-          out.push({ role: 'tool', tool_call_id: r.tool_use_id, content: r.content });
-        }
-      } else {
-        const text = m.blocks
-          .filter((b): b is Extract<ContentBlock, { type: 'text' }> => b.type === 'text')
-          .map((b) => b.text)
-          .join('\n');
-        if (text.length > 0) out.push({ role: 'user', content: text });
+        out.push({
+          role: 'tool',
+          content: toolResults.map((r) => ({
+            type: 'tool-result' as const,
+            toolCallId: r.tool_use_id,
+            toolName: '',
+            output: { type: 'text', value: r.content },
+          })),
+        });
+        continue;
       }
-    } else {
-      // assistant
       const text = m.blocks
         .filter((b): b is Extract<ContentBlock, { type: 'text' }> => b.type === 'text')
-        .map((b) => b.text)
-        .join('');
-      const tcs = m.blocks
-        .filter((b): b is Extract<ContentBlock, { type: 'tool_use' }> => b.type === 'tool_use')
-        .map((b) => ({
-          id: b.id,
-          type: 'function' as const,
-          function: { name: b.name, arguments: JSON.stringify(b.input ?? {}) },
-        }));
-      if (text.length === 0 && tcs.length === 0) continue;
-      out.push({
-        role: 'assistant',
-        content: text.length > 0 ? text : null,
-        ...(tcs.length > 0 ? { tool_calls: tcs } : {}),
-      });
+        .map((b) => b.text).join('\n');
+      if (text.length > 0) out.push({ role: 'user', content: text });
+    } else {
+      const parts: any[] = [];
+      for (const b of m.blocks) {
+        if (b.type === 'text' && b.text.length > 0) {
+          parts.push({ type: 'text', text: b.text });
+        } else if (b.type === 'tool_use') {
+          parts.push({
+            type: 'tool-call',
+            toolCallId: b.id,
+            toolName: b.name,
+            input: b.input ?? {},
+          });
+        }
+      }
+      if (parts.length > 0) out.push({ role: 'assistant', content: parts });
     }
   }
   return out;
 }
 
-function mapStop(r: string | null | undefined): StopReason {
+function mapStop(r: string | undefined): StopReason {
   switch (r) {
-    case 'stop':
-      return 'end_turn';
-    case 'tool_calls':
-    case 'function_call':
-      return 'tool_use';
-    case 'length':
-      return 'max_tokens';
-    case 'content_filter':
-      return 'refusal';
-    default:
-      return 'other';
+    case 'stop': return 'end_turn';
+    case 'tool-calls': return 'tool_use';
+    case 'length': return 'max_tokens';
+    case 'content-filter': return 'refusal';
+    case 'error': return 'error';
+    default: return 'other';
   }
 }
 
 export const openaiAdapter: LlmAdapter = {
   async stream(req: LlmRequest, cb: LlmCallbacks): Promise<LlmTurnResult> {
-    const url = defaultBase(req.baseUrl) + '/chat/completions';
+    const client = createOpenAI({
+      apiKey: req.apiKey,
+      baseURL: req.baseUrl || undefined,
+    });
 
-    const tools: OAITool[] = req.tools.map((t) => ({
-      type: 'function',
-      function: {
-        name: t.name,
+    const tools: Record<string, any> = {};
+    for (const t of req.tools) {
+      tools[t.name] = {
         description: t.description,
-        parameters: t.input_schema,
-      },
-    }));
-
-    const body: Record<string, unknown> = {
-      model: req.model,
-      stream: true,
-      max_tokens: req.maxTokens,
-      messages: [{ role: 'system', content: req.system }, ...historyToApi(req.history)],
-    };
-    if (tools.length > 0) {
-      body.tools = tools;
+        inputSchema: jsonSchema(t.input_schema),
+      };
     }
 
-    const resp = await fetch(url, {
-      method: 'POST',
-      headers: {
-        'content-type': 'application/json',
-        ...(req.apiKey ? { Authorization: `Bearer ${req.apiKey}` } : {}),
-      },
-      body: JSON.stringify(body),
+    const result = streamText({
+      model: client(req.model),
+      system: req.system,
+      messages: historyToModelMessages(req.history),
+      tools,
+      maxOutputTokens: req.maxTokens,
     });
 
-    if (!resp.ok || !resp.body) {
-      const text = await resp.text().catch(() => '');
-      throw new Error(`LLM ${resp.status}: ${text.slice(0, 400)}`);
-    }
-
-    const reader = resp.body.getReader();
-    const decoder = new TextDecoder();
-
-    let buffer = '';
-    let accumText = '';
-    // Tool call accumulators keyed by index (OpenAI streams partial JSON for arguments).
-    const toolByIndex = new Map<number, { id: string; name: string; argsRaw: string }>();
-    let finishReason: string | null | undefined;
-
-    while (true) {
-      const { value, done } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-
-      // SSE events are separated by blank lines; each event has one or more lines starting with "data: ".
-      const events = buffer.split('\n\n');
-      buffer = events.pop() ?? '';
-
-      for (const rawEvent of events) {
-        for (const line of rawEvent.split('\n')) {
-          if (!line.startsWith('data:')) continue;
-          const payload = line.slice(5).trim();
-          if (!payload || payload === '[DONE]') continue;
-          let chunk: OAIChunk;
-          try {
-            chunk = JSON.parse(payload) as OAIChunk;
-          } catch {
-            continue;
-          }
-          const choice = chunk.choices?.[0];
-          if (!choice) continue;
-          if (choice.finish_reason) finishReason = choice.finish_reason;
-          const delta = choice.delta;
-          if (!delta) continue;
-          if (typeof delta.content === 'string' && delta.content.length > 0) {
-            accumText += delta.content;
-            cb.onTextDelta(delta.content);
-          }
-          if (delta.tool_calls) {
-            for (const tc of delta.tool_calls) {
-              const idx = tc.index ?? 0;
-              let agg = toolByIndex.get(idx);
-              if (!agg) {
-                agg = { id: tc.id ?? '', name: tc.function?.name ?? '', argsRaw: '' };
-                toolByIndex.set(idx, agg);
-              }
-              if (tc.id && !agg.id) agg.id = tc.id;
-              if (tc.function?.name && !agg.name) agg.name = tc.function.name;
-              if (tc.function?.arguments) agg.argsRaw += tc.function.arguments;
-            }
-          }
-        }
-      }
-    }
-
     const content: ContentBlock[] = [];
-    if (accumText.length > 0) content.push({ type: 'text', text: accumText });
-
-    // Sort tool calls by index for stable ordering.
-    const tcKeys = Array.from(toolByIndex.keys()).sort((a, b) => a - b);
-    for (const idx of tcKeys) {
-      const agg = toolByIndex.get(idx);
-      if (!agg) continue;
-      let input: unknown = {};
-      if (agg.argsRaw.length > 0) {
-        try {
-          input = JSON.parse(agg.argsRaw);
-        } catch {
-          input = { _raw: agg.argsRaw };
+    let textBuf = '';
+    for await (const part of result.fullStream) {
+      if (part.type === 'text-delta') {
+        textBuf += part.text;
+        cb.onTextDelta(part.text);
+      } else if (part.type === 'tool-call') {
+        if (textBuf.length > 0) {
+          content.push({ type: 'text', text: textBuf });
+          textBuf = '';
         }
+        cb.onToolUse({ id: part.toolCallId, name: part.toolName, input: part.input });
+        content.push({ type: 'tool_use', id: part.toolCallId, name: part.toolName, input: part.input });
+      } else if (part.type === 'error') {
+        throw new Error(`OpenAI stream error: ${String((part as any).error)}`);
       }
-      const id = agg.id || `call_${idx}`;
-      cb.onToolUse({ id, name: agg.name, input });
-      content.push({ type: 'tool_use', id, name: agg.name, input });
     }
+    if (textBuf.length > 0) content.push({ type: 'text', text: textBuf });
 
+    const finishReason = await result.finishReason;
     return { stopReason: mapStop(finishReason), content };
   },
 };