@jussmor/sdk-ai 0.2.0

package/src/permissions.ts

@@ -0,0 +1,104 @@
+import type { Tool } from "./tool.js";
+import type { InterruptRequester } from "./interrupt.js";
+import type { InterruptRequest } from "./interrupt.js";
+import { randomUUID } from "node:crypto";
+
+export type PermissionBehavior = "allow" | "deny" | "ask";
+
+export interface PermissionRule {
+  toolName?: string;
+  pathPrefix?: string;
+  behavior: PermissionBehavior;
+  reason?: string;
+}
+
+export interface PermissionDecisionResult {
+  behavior: PermissionBehavior;
+  reason?: string;
+  updatedInput?: Record<string, unknown>;
+}
+
+export interface PermissionApprover {
+  ask(
+    tool: Tool,
+    args: Record<string, unknown>,
+    signal?: AbortSignal,
+  ): Promise<PermissionDecisionResult>;
+}
+
+export class InterruptApprover implements PermissionApprover {
+  constructor(private requester: InterruptRequester) {}
+
+  async ask(
+    tool: Tool,
+    args: Record<string, unknown>,
+    signal?: AbortSignal,
+  ): Promise<PermissionDecisionResult> {
+    const req: InterruptRequest = {
+      id: randomUUID(),
+      kind: "approval",
+      title: `Allow ${tool.name}?`,
+      description: tool.description,
+      toolName: tool.name,
+      toolArgs: args,
+      createdAt: new Date(),
+    };
+    const resp = await this.requester(req, signal);
+    if (resp.approved) {
+      return { behavior: "allow" };
+    }
+    return { behavior: "deny", reason: "user denied" };
+  }
+}
+
+export class PermissionEngine {
+  private rules: PermissionRule[] = [];
+  private approver?: PermissionApprover;
+
+  withRules(rules: PermissionRule[]): this {
+    this.rules = rules;
+    return this;
+  }
+
+  withApprover(approver: PermissionApprover): this {
+    this.approver = approver;
+    return this;
+  }
+
+  async decide(
+    tool: Tool,
+    args: Record<string, unknown>,
+    signal?: AbortSignal,
+  ): Promise<PermissionDecisionResult> {
+    for (const rule of this.rules) {
+      if (rule.toolName && rule.toolName !== tool.name) continue;
+      if (rule.pathPrefix) {
+        const path =
+          typeof args["path"] === "string" ? args["path"] : "";
+        if (!path.startsWith(rule.pathPrefix)) continue;
+      }
+      if (rule.behavior === "ask") break;
+      return { behavior: rule.behavior, reason: rule.reason };
+    }
+
+    if (tool.checkPermissions) {
+      const result = await tool.checkPermissions(signal, args);
+      if (result.decision === "deny" || result.decision === "ask_user") {
+        if (this.approver && result.decision === "ask_user") {
+          return this.approver.ask(tool, args, signal);
+        }
+        return { behavior: "deny", reason: result.reason };
+      }
+      return {
+        behavior: "allow",
+        updatedInput: result.updatedArgs as Record<string, unknown> | undefined,
+      };
+    }
+
+    if (this.approver && tool.isDestructive?.(args)) {
+      return this.approver.ask(tool, args, signal);
+    }
+
+    return { behavior: "allow" };
+  }
+}

package/src/protocol.ts

@@ -0,0 +1 @@
+export const PROTOCOL_VERSION = "1" as const;

package/src/providers/llm/anthropic.ts

@@ -0,0 +1,298 @@
+import Anthropic from "@anthropic-ai/sdk";
+import type {
+  LLMProvider,
+  ChatRequest,
+  ChatResponse,
+  ChatMessage,
+  ToolDef,
+} from "../../llm.js";
+import type { StreamingLLMProvider, StreamEvent } from "../../streaming.js";
+
+function toAnthropicMessages(
+  messages: ChatMessage[],
+): Anthropic.MessageParam[] {
+  const out: Anthropic.MessageParam[] = [];
+
+  for (const msg of messages) {
+    if (msg.role === "system") continue;
+
+    if (msg.role === "tool") {
+      const last = out[out.length - 1];
+      const toolResultBlock: Anthropic.ToolResultBlockParam = {
+        type: "tool_result",
+        tool_use_id: msg.toolCallId ?? "",
+        content: msg.content,
+      };
+      if (last?.role === "user" && Array.isArray(last.content)) {
+        (last.content as Anthropic.ToolResultBlockParam[]).push(toolResultBlock);
+      } else {
+        out.push({ role: "user", content: [toolResultBlock] });
+      }
+      continue;
+    }
+
+    if (msg.role === "assistant" && msg.toolCalls?.length) {
+      const content: Anthropic.ContentBlockParam[] = [];
+      if (msg.content) {
+        content.push({ type: "text", text: msg.content });
+      }
+      for (const tc of msg.toolCalls) {
+        let input: Record<string, unknown> = {};
+        try {
+          input = JSON.parse(tc.arguments) as Record<string, unknown>;
+        } catch {}
+        content.push({
+          type: "tool_use",
+          id: tc.id,
+          name: tc.name,
+          input,
+        });
+      }
+      out.push({ role: "assistant", content });
+      continue;
+    }
+
+    if (msg.role === "user" && (msg.images?.length || msg.documents?.length)) {
+      const content: Anthropic.ContentBlockParam[] = [];
+      for (const img of msg.images ?? []) {
+        if (img.url) {
+          // Anthropic doesn't support URL images natively — fetch as base64 or skip
+          content.push({
+            type: "text",
+            text: `[Image URL: ${img.url}]`,
+          });
+        } else if (img.source) {
+          content.push({
+            type: "image",
+            source: {
+              type: "base64",
+              media_type: (img.mediaType ?? "image/jpeg") as
+                | "image/jpeg"
+                | "image/png"
+                | "image/gif"
+                | "image/webp",
+              data: img.source,
+            },
+          });
+        }
+      }
+      if (msg.content) content.push({ type: "text", text: msg.content });
+      out.push({ role: "user", content });
+      continue;
+    }
+
+    out.push({
+      role: msg.role as "user" | "assistant",
+      content: msg.content,
+    });
+  }
+
+  return out;
+}
+
+function toAnthropicTools(tools: ToolDef[]): Anthropic.Tool[] {
+  return tools.map((t) => ({
+    name: t.function.name,
+    description: t.function.description,
+    input_schema: t.function.parameters as Anthropic.Tool.InputSchema,
+  }));
+}
+
+function extractSystemPrompt(messages: ChatMessage[]): string {
+  return messages
+    .filter((m) => m.role === "system")
+    .map((m) => m.content)
+    .join("\n\n");
+}
+
+export interface AnthropicProviderOptions {
+  apiKey?: string;
+  baseURL?: string;
+  defaultModel?: string;
+  defaultMaxTokens?: number;
+}
+
+export class AnthropicProvider implements StreamingLLMProvider {
+  private client: Anthropic;
+  private defaultModel: string;
+  private defaultMaxTokens: number;
+
+  constructor(opts: AnthropicProviderOptions = {}) {
+    this.client = new Anthropic({
+      apiKey: opts.apiKey ?? process.env["ANTHROPIC_API_KEY"],
+      baseURL: opts.baseURL,
+    });
+    this.defaultModel = opts.defaultModel ?? "claude-sonnet-4-6-20251001";
+    this.defaultMaxTokens = opts.defaultMaxTokens ?? 8096;
+  }
+
+  async chat(req: ChatRequest, signal?: AbortSignal): Promise<ChatResponse> {
+    const system = extractSystemPrompt(req.messages);
+    const messages = toAnthropicMessages(req.messages);
+    const tools = req.tools?.length ? toAnthropicTools(req.tools) : undefined;
+
+    const params: Anthropic.MessageCreateParamsNonStreaming = {
+      model: req.model ?? this.defaultModel,
+      max_tokens: req.maxTokens ?? this.defaultMaxTokens,
+      messages,
+      ...(system ? { system } : {}),
+      ...(tools ? { tools } : {}),
+      ...(req.temperature != null ? { temperature: req.temperature } : {}),
+      ...(req.topP != null ? { top_p: req.topP } : {}),
+      ...(req.topK != null ? { top_k: req.topK } : {}),
+      ...(req.stop?.length ? { stop_sequences: req.stop } : {}),
+      ...(req.thinkingBudget
+        ? {
+            thinking: {
+              type: "enabled",
+              budget_tokens: req.thinkingBudget,
+            } as Anthropic.ThinkingConfigParam,
+          }
+        : {}),
+    };
+
+    const resp = await this.client.messages.create(params, {
+      signal,
+    });
+
+    let content = "";
+    let thinkingContent = "";
+    const toolCalls: ChatResponse["toolCalls"] = [];
+
+    for (const block of resp.content) {
+      if (block.type === "text") {
+        content += block.text;
+      } else if (block.type === "thinking") {
+        thinkingContent += block.thinking;
+      } else if (block.type === "tool_use") {
+        toolCalls.push({
+          id: block.id,
+          name: block.name,
+          arguments: JSON.stringify(block.input),
+        });
+      }
+    }
+
+    return {
+      content,
+      thinkingContent: thinkingContent || undefined,
+      toolCalls: toolCalls.length ? toolCalls : undefined,
+      finishReason: resp.stop_reason ?? "stop",
+      usage: {
+        promptTokens: resp.usage.input_tokens,
+        completionTokens: resp.usage.output_tokens,
+        totalTokens: resp.usage.input_tokens + resp.usage.output_tokens,
+      },
+      model: resp.model,
+    };
+  }
+
+  async *chatStream(
+    req: ChatRequest,
+    signal?: AbortSignal,
+  ): AsyncGenerator<StreamEvent> {
+    const system = extractSystemPrompt(req.messages);
+    const messages = toAnthropicMessages(req.messages);
+    const tools = req.tools?.length ? toAnthropicTools(req.tools) : undefined;
+
+    const params: Anthropic.MessageCreateParamsStreaming = {
+      model: req.model ?? this.defaultModel,
+      max_tokens: req.maxTokens ?? this.defaultMaxTokens,
+      messages,
+      stream: true,
+      ...(system ? { system } : {}),
+      ...(tools ? { tools } : {}),
+      ...(req.temperature != null ? { temperature: req.temperature } : {}),
+      ...(req.topP != null ? { top_p: req.topP } : {}),
+      ...(req.topK != null ? { top_k: req.topK } : {}),
+      ...(req.stop?.length ? { stop_sequences: req.stop } : {}),
+      ...(req.thinkingBudget
+        ? {
+            thinking: {
+              type: "enabled",
+              budget_tokens: req.thinkingBudget,
+            } as Anthropic.ThinkingConfigParam,
+          }
+        : {}),
+    };
+
+    const stream = this.client.messages.stream(params, { signal });
+
+    let promptTokens = 0;
+    let completionTokens = 0;
+
+    const toolCallMap = new Map<
+      number,
+      { id: string; name: string; argsBuf: string }
+    >();
+
+    for await (const chunk of stream) {
+      if (signal?.aborted) break;
+
+      if (chunk.type === "message_start") {
+        promptTokens = chunk.message.usage.input_tokens;
+        completionTokens = chunk.message.usage.output_tokens;
+        continue;
+      }
+
+      if (chunk.type === "message_delta") {
+        completionTokens = chunk.usage.output_tokens;
+        continue;
+      }
+
+      if (chunk.type === "content_block_start") {
+        if (chunk.content_block.type === "tool_use") {
+          toolCallMap.set(chunk.index, {
+            id: chunk.content_block.id,
+            name: chunk.content_block.name,
+            argsBuf: "",
+          });
+        }
+        continue;
+      }
+
+      if (chunk.type === "content_block_delta") {
+        if (chunk.delta.type === "text_delta") {
+          yield { type: "delta", delta: chunk.delta.text };
+        } else if (chunk.delta.type === "thinking_delta") {
+          yield { type: "thinking", thinking: chunk.delta.thinking };
+        } else if (chunk.delta.type === "input_json_delta") {
+          const tc = toolCallMap.get(chunk.index);
+          if (tc) tc.argsBuf += chunk.delta.partial_json;
+        }
+        continue;
+      }
+
+      if (chunk.type === "content_block_stop") {
+        const tc = toolCallMap.get(chunk.index);
+        if (tc) {
+          yield {
+            type: "tool_call",
+            toolCall: { id: tc.id, name: tc.name, arguments: tc.argsBuf },
+          };
+          toolCallMap.delete(chunk.index);
+        }
+        continue;
+      }
+
+      if (chunk.type === "message_stop") {
+        yield {
+          type: "done",
+          final: {
+            finalContent: "",
+            providerReasoning: "",
+            totalTurns: 1,
+            totalUsage: {
+              promptTokens,
+              completionTokens,
+              totalTokens: promptTokens + completionTokens,
+            },
+            messages: [],
+            reasoningTrace: [],
+            stopReason: "complete",
+          },
+        };
+      }
+    }
+  }
+}

package/src/providers/llm/ollama.ts

@@ -0,0 +1,219 @@
+import type {
+  LLMProvider,
+  ChatRequest,
+  ChatResponse,
+  ChatMessage,
+  ToolCallEntry,
+} from "../../llm.js";
+import type { StreamingLLMProvider, StreamEvent } from "../../streaming.js";
+
+interface OllamaMessage {
+  role: string;
+  content: string;
+  images?: string[];
+  tool_calls?: Array<{
+    function: { name: string; arguments: Record<string, unknown> };
+  }>;
+}
+
+interface OllamaChatResponse {
+  model: string;
+  message: OllamaMessage;
+  done: boolean;
+  done_reason?: string;
+  prompt_eval_count?: number;
+  eval_count?: number;
+}
+
+function toOllamaMessages(messages: ChatMessage[]): OllamaMessage[] {
+  const out: OllamaMessage[] = [];
+  for (const msg of messages) {
+    if (msg.role === "system") {
+      out.push({ role: "system", content: msg.content });
+      continue;
+    }
+    if (msg.role === "tool") {
+      out.push({ role: "tool", content: msg.content });
+      continue;
+    }
+    const om: OllamaMessage = { role: msg.role, content: msg.content };
+    if (msg.images?.length) {
+      om.images = msg.images
+        .filter((i) => i.source)
+        .map((i) => i.source!);
+    }
+    if (msg.toolCalls?.length) {
+      om.tool_calls = msg.toolCalls.map((tc) => ({
+        function: {
+          name: tc.name,
+          arguments: JSON.parse(tc.arguments) as Record<string, unknown>,
+        },
+      }));
+    }
+    out.push(om);
+  }
+  return out;
+}
+
+export interface OllamaProviderOptions {
+  baseURL?: string;
+  defaultModel?: string;
+  nativeToolCalls?: boolean;
+  temperature?: number;
+}
+
+export class OllamaProvider implements StreamingLLMProvider {
+  private baseURL: string;
+  private defaultModel: string;
+  private nativeToolCalls: boolean;
+  private temperature?: number;
+
+  constructor(opts: OllamaProviderOptions = {}) {
+    this.baseURL =
+      (opts.baseURL ?? process.env["OLLAMA_BASE_URL"] ?? "http://localhost:11434").replace(/\/$/, "");
+    this.defaultModel = opts.defaultModel ?? "llama3.1";
+    this.nativeToolCalls = opts.nativeToolCalls ?? false;
+    this.temperature = opts.temperature;
+  }
+
+  async chat(req: ChatRequest, signal?: AbortSignal): Promise<ChatResponse> {
+    const body: Record<string, unknown> = {
+      model: req.model ?? this.defaultModel,
+      messages: toOllamaMessages(req.messages),
+      stream: false,
+      options: this.temperature != null ? { temperature: this.temperature } : undefined,
+    };
+
+    if (this.nativeToolCalls && req.tools?.length) {
+      body["tools"] = req.tools.map((t) => ({
+        type: "function",
+        function: {
+          name: t.function.name,
+          description: t.function.description,
+          parameters: t.function.parameters,
+        },
+      }));
+    }
+
+    const resp = await fetch(`${this.baseURL}/api/chat`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      signal,
+    });
+
+    if (!resp.ok) {
+      throw new Error(`Ollama error: ${resp.status} ${await resp.text()}`);
+    }
+
+    const data = (await resp.json()) as OllamaChatResponse;
+    const toolCalls: ToolCallEntry[] = [];
+
+    if (data.message.tool_calls?.length) {
+      for (let i = 0; i < data.message.tool_calls.length; i++) {
+        const tc = data.message.tool_calls[i]!;
+        toolCalls.push({
+          id: `ollama-${i}`,
+          name: tc.function.name,
+          arguments: JSON.stringify(tc.function.arguments),
+        });
+      }
+    }
+
+    const promptTokens = data.prompt_eval_count ?? 0;
+    const completionTokens = data.eval_count ?? 0;
+
+    return {
+      content: data.message.content,
+      toolCalls: toolCalls.length ? toolCalls : undefined,
+      finishReason: data.done_reason ?? "stop",
+      usage: {
+        promptTokens,
+        completionTokens,
+        totalTokens: promptTokens + completionTokens,
+      },
+      model: data.model,
+    };
+  }
+
+  async *chatStream(
+    req: ChatRequest,
+    signal?: AbortSignal,
+  ): AsyncGenerator<StreamEvent> {
+    const body: Record<string, unknown> = {
+      model: req.model ?? this.defaultModel,
+      messages: toOllamaMessages(req.messages),
+      stream: true,
+      options: this.temperature != null ? { temperature: this.temperature } : undefined,
+    };
+
+    if (this.nativeToolCalls && req.tools?.length) {
+      body["tools"] = req.tools.map((t) => ({
+        type: "function",
+        function: {
+          name: t.function.name,
+          description: t.function.description,
+          parameters: t.function.parameters,
+        },
+      }));
+    }
+
+    const resp = await fetch(`${this.baseURL}/api/chat`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      signal,
+    });
+
+    if (!resp.ok) {
+      throw new Error(`Ollama error: ${resp.status} ${await resp.text()}`);
+    }
+
+    const reader = resp.body?.getReader();
+    if (!reader) throw new Error("Ollama: no response body");
+
+    const decoder = new TextDecoder();
+    let buf = "";
+    let promptTokens = 0;
+    let completionTokens = 0;
+    let fullContent = "";
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (signal?.aborted) { reader.cancel(); break; }
+      buf += decoder.decode(value, { stream: true });
+      const lines = buf.split("\n");
+      buf = lines.pop() ?? "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        const data = JSON.parse(trimmed) as OllamaChatResponse;
+        if (data.message?.content) {
+          fullContent += data.message.content;
+          yield { type: "delta", delta: data.message.content };
+        }
+        if (data.done) {
+          promptTokens = data.prompt_eval_count ?? 0;
+          completionTokens = data.eval_count ?? 0;
+          yield {
+            type: "done",
+            final: {
+              finalContent: fullContent,
+              providerReasoning: "",
+              totalTurns: 1,
+              totalUsage: {
+                promptTokens,
+                completionTokens,
+                totalTokens: promptTokens + completionTokens,
+              },
+              messages: [],
+              reasoningTrace: [],
+              stopReason: "complete",
+            },
+          };
+        }
+      }
+    }
+  }
+}