sdlc-agent-4-enterprise-server 1.0.0

package/extension/src/langgraph/providers/index.ts

@@ -0,0 +1,114 @@
+/**
+ * LLM Provider Factory — KSA-210
+ * Creates provider instances based on VS Code configuration.
+ * Providers are lazy-loaded to minimize extension activation cost.
+ */
+
+import * as vscode from "vscode";
+import type { LlmProvider, LlmProviderType } from "../llm-provider";
+
+/** Extended provider type including onnx */
+export type ExtendedLlmProviderType = LlmProviderType | "onnx";
+
+/** VS Code secret keys for each provider */
+const SECRET_KEYS: Record<string, string> = {
+  anthropic: "kiroSdlc.anthropicApiKey",
+  openai: "kiroSdlc.openaiApiKey",
+};
+
+/**
+ * Create an LlmProvider from VS Code settings.
+ * Reads kiroSdlc.llmProvider, kiroSdlc.llmModel, kiroSdlc.ollamaUrl from workspace config.
+ */
+export function createLlmProvider(secrets?: vscode.SecretStorage): LlmProvider {
+  const config = vscode.workspace.getConfiguration("kiroSdlc");
+  const providerType = config.get<LlmProviderType>("llmProvider", "anthropic");
+  const customModel = config.get<string>("llmModel", "");
+  const ollamaUrl = config.get<string>("ollamaUrl", "http://localhost:11434");
+  const anthropicBaseUrl = config.get<string>("anthropicBaseUrl", "");
+  // Read per-provider base URLs
+  const openaiBaseUrl = providerType === "lmstudio"
+    ? (config.get<string>("lmstudioBaseUrl", "") || "http://localhost:1234/v1")
+    : providerType === "openrouter"
+    ? (config.get<string>("openrouterBaseUrl", "") || "https://openrouter.ai/api/v1")
+    : config.get<string>("openaiBaseUrl", "");
+
+  return createProviderByType(providerType, secrets, customModel, ollamaUrl, anthropicBaseUrl, openaiBaseUrl);
+}
+
+/**
+ * Create a specific provider type with explicit configuration.
+ */
+export function createProviderByType(
+  type: LlmProviderType | ExtendedLlmProviderType,
+  secrets?: vscode.SecretStorage,
+  customModel?: string,
+  ollamaUrl?: string,
+  anthropicBaseUrl?: string,
+  openaiBaseUrl?: string
+): LlmProvider {
+  switch (type) {
+    case "anthropic": {
+      const { AnthropicProvider } = require("./anthropic-provider");
+      return new AnthropicProvider(
+        secrets ? () => secrets.get(SECRET_KEYS.anthropic) : () => Promise.resolve(undefined),
+        anthropicBaseUrl || undefined
+      );
+    }
+    case "openai": {
+      const { OpenAIProvider } = require("./openai-provider");
+      return new OpenAIProvider(
+        secrets ? () => secrets.get(SECRET_KEYS.openai) : () => Promise.resolve(undefined),
+        openaiBaseUrl || undefined
+      );
+    }
+    case "ollama": {
+      const { OllamaProvider } = require("./ollama-provider");
+      return new OllamaProvider(ollamaUrl, customModel || undefined);
+    }
+    case "onnx": {
+      const { OnnxProvider } = require("./onnx-provider");
+      const workspaceRoot = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath || ".";
+      return new OnnxProvider(workspaceRoot, customModel || undefined);
+    }
+    case "kiro": {
+      // Backward compat — alias "kiro" to anthropic + the configured gateway
+      // base URL. The gateway now runs as the standalone Kiro Gateway extension
+      // (default http://127.0.0.1:8990/anthropic via kiroSdlc.anthropicBaseUrl).
+      const config2 = vscode.workspace.getConfiguration("kiroSdlc");
+      const gatewayUrl = anthropicBaseUrl || config2.get<string>("anthropicBaseUrl", "http://127.0.0.1:8990/anthropic");
+      const { AnthropicProvider } = require("./anthropic-provider");
+      return new AnthropicProvider(
+        secrets ? () => secrets.get(SECRET_KEYS.anthropic) : () => Promise.resolve(undefined),
+        gatewayUrl
+      );
+    }
+    case "lmstudio": {
+      // LM Studio uses OpenAI-compatible API at localhost:1234
+      const { OpenAIProvider } = require("./openai-provider");
+      const lmStudioUrl = openaiBaseUrl || "http://localhost:1234/v1";
+      return new OpenAIProvider(
+        () => Promise.resolve("not-needed"),
+        lmStudioUrl
+      );
+    }
+    case "openrouter": {
+      // OpenRouter uses OpenAI-compatible API
+      const { OpenAIProvider } = require("./openai-provider");
+      const orUrl = openaiBaseUrl || "https://openrouter.ai/api/v1";
+      return new OpenAIProvider(
+        secrets ? () => secrets.get(SECRET_KEYS.openai) : () => Promise.resolve(undefined),
+        orUrl
+      );
+    }
+    default:
+      throw new Error(`Unknown LLM provider type: ${type}`);
+  }
+}
+
+/**
+ * Get the secret storage key for a given provider type.
+ */
+export function getSecretKeyForProvider(type: LlmProviderType): string | undefined {
+  return SECRET_KEYS[type];
+}

package/extension/src/langgraph/providers/kiro-client.ts

@@ -0,0 +1,151 @@
+/**
+ * KiroClient — KSA-231
+ * Main LlmProvider implementation for the Kiro API.
+ * Orchestrates TokenManager, AnthropicAdapter, StreamHandler, and ModelRegistry.
+ */
+
+import * as vscode from "vscode";
+import type { LlmProvider, LlmMessage, LlmOptions, LlmResponse, LlmToolCall } from "../llm-provider";
+import type { McpToolDefinition } from "../tool-registry";
+import { TokenManager, KiroCredentialError } from "./token-manager";
+import { AnthropicAdapter } from "./anthropic-adapter";
+import { StreamHandler, KiroStreamError } from "./stream-handler";
+import { ModelRegistry } from "./model-registry";
+import { sendRequestWithRetry } from "./kiro-http-helpers";
+import type { LlmProviderType } from "../llm-provider";
+
+const DEFAULT_MAX_TOKENS = 4096;
+
+export class KiroClient implements LlmProvider {
+  readonly type: LlmProviderType = "kiro" as LlmProviderType;
+
+  private readonly tokenManager: TokenManager;
+  private readonly adapter: AnthropicAdapter;
+  private readonly streamHandler: StreamHandler;
+  private readonly modelRegistry: ModelRegistry;
+  private readonly outputChannel: vscode.OutputChannel;
+  private initialized = false;
+
+  constructor(outputChannel: vscode.OutputChannel) {
+    this.outputChannel = outputChannel;
+    this.tokenManager = new TokenManager(outputChannel);
+    this.adapter = new AnthropicAdapter();
+    this.streamHandler = new StreamHandler();
+    this.modelRegistry = new ModelRegistry(this.tokenManager, outputChannel);
+  }
+
+  async chat(messages: LlmMessage[], options?: LlmOptions): Promise<string> {
+    await this.ensureInitialized();
+    const result: string[] = [];
+    for await (const chunk of this.chatStream(messages, options)) { result.push(chunk); }
+    return result.join("");
+  }
+
+  async *chatStream(messages: LlmMessage[], options?: LlmOptions): AsyncGenerator<string> {
+    await this.ensureInitialized();
+    const model = await this.resolveModel(options?.model);
+    const region = this.tokenManager.getRegion();
+    if (!region) { throw new KiroApiError("No region available."); }
+
+    const requestBody = this.adapter.buildRequestBody(messages, { ...options, model });
+    requestBody.stream = true;
+
+    const response = await this.sendRequest(region, model, requestBody, options?.signal);
+    this.log("INFO", `Chat request: model=${model}, messages=${messages.length}, stream=true`);
+
+    const startTime = Date.now();
+    let tokenCount = 0;
+    for await (const chunk of this.streamHandler.processStream(response, options?.signal)) {
+      yield chunk;
+      tokenCount++;
+    }
+    const duration = ((Date.now() - startTime) / 1000).toFixed(1);
+    this.log("INFO", `Stream complete: ~${tokenCount} chunks in ${duration}s`);
+  }
+
+  async chatWithTools(
+    messages: LlmMessage[], tools: McpToolDefinition[], options?: LlmOptions
+  ): Promise<LlmResponse> {
+    await this.ensureInitialized();
+    const model = await this.resolveModel(options?.model);
+    const region = this.tokenManager.getRegion();
+    if (!region) { throw new KiroApiError("No region available."); }
+
+    const requestBody = this.adapter.buildRequestBody(messages, { ...options, model }, tools);
+    requestBody.stream = true;
+
+    const response = await this.sendRequest(region, model, requestBody, options?.signal);
+    this.log("INFO", `Chat request (tools+stream): model=${model}, tools=${tools.length}`);
+
+    let textBuffer = "";
+    const toolCalls: LlmToolCall[] = [];
+    for await (const event of this.streamHandler.processStreamWithToolUse(response, options?.signal)) {
+      if (event.type === "text") { textBuffer += event.text; }
+      else if (event.type === "tool_use") {
+        toolCalls.push({ id: event.id, name: event.name, arguments: event.input });
+      }
+    }
+    if (toolCalls.length > 0) { return { type: "tool_use", toolCalls }; }
+    return { type: "text", text: textBuffer };
+  }
+
+  async isAvailable(): Promise<boolean> {
+    try {
+      await this.ensureInitialized();
+      const status = this.tokenManager.getStatus();
+      return status === "active" || status === "refreshing";
+    } catch { return false; }
+  }
+
+  dispose(): void {
+    this.tokenManager.dispose();
+    this.modelRegistry.dispose();
+    this.outputChannel.appendLine("[INFO] KiroClient: disposed");
+  }
+
+  getModelRegistry(): ModelRegistry { return this.modelRegistry; }
+  getTokenManager(): TokenManager { return this.tokenManager; }
+
+  getContextWindow(): number {
+    // Kiro API uses Claude models — 200K context. Future: read from ModelRegistry per selected model.
+    return 200000;
+  }
+
+  private async ensureInitialized(): Promise<void> {
+    if (this.initialized) { return; }
+    this.initialized = true;
+    await this.tokenManager.initialize();
+  }
+
+  private async resolveModel(explicitModel?: string): Promise<string> {
+    if (explicitModel) { return explicitModel; }
+    const settingsModel = this.modelRegistry.getSelectedModel();
+    if (settingsModel) { return settingsModel; }
+    const models = await this.modelRegistry.getModels();
+    if (models.length > 0) {
+      const chatModel = models.find(m => m.capabilities.chat) || models[0];
+      return chatModel.id;
+    }
+    return "";
+  }
+
+  private async sendRequest(region: string, model: string, body: any, signal?: AbortSignal): Promise<Response> {
+    const port = vscode.workspace.getConfiguration("kiroSdlc").get<number>("mcpServerPort", 9181);
+    const url = this.adapter.getEndpointUrl(port);
+    return sendRequestWithRetry(
+      url, body, model, this.tokenManager, this.adapter, signal,
+      (level, msg) => this.log(level, msg)
+    );
+  }
+
+  private log(level: string, message: string): void {
+    this.outputChannel.appendLine(`[${level}] KiroClient: ${message}`);
+  }
+}
+
+export class KiroApiError extends Error {
+  constructor(message: string, options?: ErrorOptions) {
+    super(message, options);
+    this.name = "KiroApiError";
+  }
+}

package/extension/src/langgraph/providers/kiro-http-helpers.ts

@@ -0,0 +1,93 @@
+/**
+ * HTTP helper functions for KiroClient.
+ * Handles fetch with timeout, retry logic for 401/429/5xx.
+ */
+
+import type { TokenManager } from "./token-manager";
+import type { AnthropicAdapter } from "./anthropic-adapter";
+
+const CONNECT_TIMEOUT_MS = 30_000;
+
+/**
+ * Fetch with connect timeout, respecting an optional external abort signal.
+ */
+export async function fetchWithTimeout(url: string, init: RequestInit): Promise<Response> {
+  const existingSignal = init.signal;
+  if (!existingSignal) {
+    return fetch(url, { ...init, signal: AbortSignal.timeout(CONNECT_TIMEOUT_MS) });
+  }
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), CONNECT_TIMEOUT_MS);
+  existingSignal.addEventListener("abort", () => controller.abort());
+  try {
+    return await fetch(url, { ...init, signal: controller.signal });
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+
+/**
+ * Send a streaming request with automatic 401/429/5xx retry.
+ */
+export async function sendRequestWithRetry(
+  url: string,
+  body: any,
+  model: string,
+  tokenManager: TokenManager,
+  adapter: AnthropicAdapter,
+  signal: AbortSignal | undefined,
+  log: (level: string, message: string) => void
+): Promise<Response> {
+  const accessToken = await tokenManager.getAccessToken();
+  const headers = adapter.buildRequestHeaders(accessToken, model);
+
+  let response = await fetchWithTimeout(url, {
+    method: "POST", headers, body: JSON.stringify(body), signal,
+  });
+
+  if (response.status === 401) {
+    log("WARN", "Received 401 — refreshing token and retrying");
+    await tokenManager.refreshToken();
+    const newToken = await tokenManager.getAccessToken();
+    const newHeaders = adapter.buildRequestHeaders(newToken, model);
+    response = await fetchWithTimeout(url, {
+      method: "POST", headers: newHeaders, body: JSON.stringify(body), signal,
+    });
+    if (response.status === 401) {
+      throw new Error("Authentication failed after token refresh. Please re-login via Kiro IDE.");
+    }
+  }
+
+  if (response.status === 429) {
+    const retryAfter = response.headers.get("Retry-After");
+    const waitMs = retryAfter ? parseInt(retryAfter, 10) * 1000 : 5000;
+    log("WARN", `Rate limited (429). Waiting ${waitMs}ms`);
+    await sleep(waitMs);
+    const refreshedToken = await tokenManager.getAccessToken();
+    const retryHeaders = adapter.buildRequestHeaders(refreshedToken, model);
+    response = await fetchWithTimeout(url, {
+      method: "POST", headers: retryHeaders, body: JSON.stringify(body), signal,
+    });
+  }
+
+  if (response.status >= 500) {
+    log("WARN", `Server error ${response.status} — retrying once`);
+    await sleep(1000);
+    const refreshedToken = await tokenManager.getAccessToken();
+    const retryHeaders = adapter.buildRequestHeaders(refreshedToken, model);
+    response = await fetchWithTimeout(url, {
+      method: "POST", headers: retryHeaders, body: JSON.stringify(body), signal,
+    });
+  }
+
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => "Unknown error");
+    throw new Error(`Kiro API error ${response.status}: ${errorText}`);
+  }
+
+  return response;
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}

package/extension/src/langgraph/providers/model-parser.ts

@@ -0,0 +1,33 @@
+/**
+ * Model response parser --- KSA-231
+ */
+
+import type { KiroModel } from "./model-registry";
+
+export function parseModelsResponse(data: { data?: any[]; models?: any[] }): KiroModel[] {
+  if (Array.isArray(data.data)) {
+    return data.data.filter((m: any) => m.id).map((m: any) => ({
+      id: m.id,
+      displayName: m.display_name || m.displayName || m.id,
+      provider: "kiro",
+      contextWindow: m.contextWindow || 0,
+      capabilities: { chat: m.capabilities?.chat ?? true, code: m.capabilities?.code ?? false, vision: m.capabilities?.vision ?? false },
+      maxOutputTokens: m.maxOutputTokens || undefined,
+    }));
+  }
+  if (!data.models || !Array.isArray(data.models)) { return []; }
+  return data.models.filter((m: any) => m.id && m.displayName).map((m: any) => ({
+    id: m.id,
+    displayName: m.displayName || m.id,
+    provider: m.provider || "unknown",
+    capabilities: { chat: m.capabilities?.chat ?? true, code: m.capabilities?.code ?? false, vision: m.capabilities?.vision ?? false },
+    contextWindow: m.contextWindow || 0,
+    maxOutputTokens: m.maxOutputTokens || undefined,
+  }));
+}
+
+export function modelsChanged(prev: KiroModel[], next: KiroModel[]): boolean {
+  if (prev.length !== next.length) { return true; }
+  const prevIds = new Set(prev.map(m => m.id));
+  return next.some(m => !prevIds.has(m.id));
+}

package/extension/src/langgraph/providers/model-registry.ts

@@ -0,0 +1,98 @@
+/**
+ * ModelRegistry --- KSA-231
+ * Fetches and caches available models from Kiro API with 1-hour TTL.
+ */
+
+import * as vscode from "vscode";
+import { TokenManager } from "./token-manager";
+import { AnthropicAdapter } from "./anthropic-adapter";
+import { parseModelsResponse, modelsChanged } from "./model-parser";
+
+export interface KiroModel {
+  id: string;
+  displayName: string;
+  provider: string;
+  contextWindow: number;
+  capabilities: { chat: boolean; code: boolean; vision: boolean };
+  maxOutputTokens?: number;
+}
+
+interface ModelCache { models: KiroModel[]; fetchedAt: number; etag: string | null; }
+
+const CACHE_TTL_MS = 60 * 60 * 1000;
+const STALE_THRESHOLD_MS = 5 * 60 * 1000;
+const REQUEST_TIMEOUT_MS = 10_000;
+
+export class ModelRegistry implements vscode.Disposable {
+  private cache: ModelCache | null = null;
+  private backgroundRefreshInProgress = false;
+  private readonly adapter = new AnthropicAdapter();
+  private readonly _onModelsChanged = new vscode.EventEmitter<KiroModel[]>();
+  readonly onModelsChanged: vscode.Event<KiroModel[]> = this._onModelsChanged.event;
+  private readonly tokenManager: TokenManager;
+  private readonly outputChannel: vscode.OutputChannel;
+
+  constructor(tokenManager: TokenManager, outputChannel: vscode.OutputChannel) {
+    this.tokenManager = tokenManager;
+    this.outputChannel = outputChannel;
+  }
+
+  async getModels(forceRefresh = false): Promise<KiroModel[]> {
+    const now = Date.now();
+    if (forceRefresh || !this.cache) { return this.fetchModels(); }
+    const cacheAge = now - this.cache.fetchedAt;
+    if (cacheAge < STALE_THRESHOLD_MS) { return this.cache.models; }
+    if (cacheAge < CACHE_TTL_MS) { this.backgroundRefresh(); return this.cache.models; }
+    return this.fetchModels();
+  }
+
+  getSelectedModel(): string {
+    return vscode.workspace.getConfiguration("kiroSdlc").get<string>("kiroModel", "");
+  }
+
+  async setSelectedModel(modelId: string): Promise<void> {
+    await vscode.workspace.getConfiguration("kiroSdlc").update("kiroModel", modelId, vscode.ConfigurationTarget.Global);
+  }
+
+  dispose(): void { this._onModelsChanged.dispose(); }
+
+  private async fetchModels(): Promise<KiroModel[]> {
+    try {
+      const port = vscode.workspace.getConfiguration("kiroSdlc").get<number>("mcpServerPort", 9181);
+      const url = this.adapter.getModelsEndpointUrl(port);
+      const headers: Record<string, string> = { "Content-Type": "application/json" };
+      if (this.cache?.etag) { headers["If-None-Match"] = this.cache.etag; }
+      const response = await fetch(url, { method: "GET", headers, signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS) });
+      if (response.status === 304) { this.cache!.fetchedAt = Date.now(); return this.cache!.models; }
+      if (!response.ok) { this.log("WARN", `Models gateway returned ${response.status}`); return this.cache?.models || []; }
+      const data = await response.json() as { data?: any[]; models?: any[] };
+      const models = parseModelsResponse(data);
+      const etag = response.headers.get("ETag") || null;
+      const previousModels = this.cache?.models || [];
+      this.cache = { models, fetchedAt: Date.now(), etag };
+      if (modelsChanged(previousModels, models)) {
+        this._onModelsChanged.fire(models);
+        this.log("INFO", `Models updated: ${models.length} models`);
+      }
+      const selected = this.getSelectedModel();
+      if (!selected && models.length > 0) {
+        const defaultModel = models.find(m => m.capabilities.chat) || models[0];
+        await this.setSelectedModel(defaultModel.id);
+      }
+      return models;
+    } catch (err) {
+      this.log("ERROR", `Failed to fetch models: ${(err as Error).message}`);
+      return this.cache?.models || [];
+    }
+  }
+
+  private backgroundRefresh(): void {
+    if (this.backgroundRefreshInProgress) { return; }
+    this.backgroundRefreshInProgress = true;
+    this.fetchModels().finally(() => { this.backgroundRefreshInProgress = false; });
+  }
+
+  private log(level: string, message: string): void {
+    this.outputChannel.appendLine(`[${level}] ModelRegistry: ${message}`);
+  }
+}

package/extension/src/langgraph/providers/ollama-provider.ts

@@ -0,0 +1,114 @@
+/**
+ * OllamaProvider --- KSA-210
+ * LLM provider backed by Ollama REST API (local inference).
+ * Extends BaseLlmProvider for shared availability check and streaming.
+ */
+import type { LlmMessage, LlmOptions, LlmResponse } from "../llm-provider";
+import type { McpToolDefinition } from "../tool-registry";
+import { BaseLlmProvider } from "./BaseLlmProvider";
+import { ollamaChatWithTools } from "./ollama-tools";
+
+const DEFAULT_MODEL = "llama3.1";
+const DEFAULT_BASE_URL = "http://localhost:11434";
+
+export class OllamaProvider extends BaseLlmProvider {
+  readonly type = "ollama" as const;
+  private readonly baseUrl: string;
+  private readonly defaultModel: string;
+
+  constructor(baseUrl?: string, defaultModel?: string) {
+    super();
+    this.baseUrl = (baseUrl || DEFAULT_BASE_URL).replace(/\/$/, "");
+    this.defaultModel = defaultModel || DEFAULT_MODEL;
+    this.contextWindowTokens = 8192; // Conservative default for Ollama models
+  }
+
+  /** Fetch actual context window from Ollama /api/show endpoint */
+  async detectContextWindow(): Promise<void> {
+    try {
+      const response = await fetch(`${this.baseUrl}/api/show`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ name: this.defaultModel }),
+        signal: AbortSignal.timeout(5000),
+      });
+      if (response.ok) {
+        const data = await response.json() as { model_info?: Record<string, unknown> };
+        const ctxLen = data.model_info?.["context_length"] as number
+          || data.model_info?.["llama.context_length"] as number;
+        if (ctxLen && ctxLen > 0) { this.contextWindowTokens = ctxLen; }
+      }
+    } catch { /* keep default */ }
+  }
+
+  async chat(messages: LlmMessage[], options?: LlmOptions): Promise<string> {
+    const body = this.buildChatBody(messages, options, false);
+    const response = await fetch(`${this.baseUrl}/api/chat`, {
+      method: "POST", headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body), signal: options?.signal,
+    });
+    if (!response.ok) {
+      throw new Error(`Ollama API error ${response.status}: ${await response.text().catch(() => "Unknown")}`);
+    }
+    const data = await response.json() as { message?: { content?: string } };
+    return data.message?.content || "";
+  }
+
+  async *chatStream(messages: LlmMessage[], options?: LlmOptions): AsyncGenerator<string> {
+    const body = this.buildChatBody(messages, options, true);
+    const response = await fetch(`${this.baseUrl}/api/chat`, {
+      method: "POST", headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body), signal: options?.signal,
+    });
+    if (!response.ok) {
+      throw new Error(`Ollama API error ${response.status}: ${await response.text().catch(() => "Unknown")}`);
+    }
+    yield* this.readStream(response, (parsed) => {
+      return parsed.message?.content || null;
+    });
+  }
+
+  async chatWithTools(messages: LlmMessage[], tools: McpToolDefinition[], options?: LlmOptions): Promise<LlmResponse> {
+    return ollamaChatWithTools(
+      this.baseUrl, this.defaultModel, messages, tools, options,
+      this.formatMessages.bind(this),
+    );
+  }
+
+  dispose(): void {}
+
+  // --- Template Method hooks ---
+
+  protected async isConfigured(): Promise<boolean> {
+    return true; // Always local, no config needed
+  }
+
+  protected getHealthCheckUrl(): string {
+    return `${this.baseUrl}/api/tags`;
+  }
+
+  protected isHealthyStatus(status: number): boolean {
+    return status === 200;
+  }
+
+  // --- Private helpers ---
+
+  private buildChatBody(messages: LlmMessage[], options: LlmOptions | undefined, stream: boolean): Record<string, unknown> {
+    const body: Record<string, unknown> = {
+      model: options?.model || this.defaultModel,
+      messages: this.formatMessages(messages),
+      stream,
+    };
+    if (options?.temperature !== undefined) {
+      body.options = { temperature: options.temperature };
+    }
+    return body;
+  }
+
+  private formatMessages(messages: LlmMessage[]): Array<{ role: string; content: string }> {
+    return messages.map((m) => {
+      if (m.role === "tool") { return { role: "tool", content: m.content }; }
+      return { role: m.role, content: m.content };
+    });
+  }
+}

package/extension/src/langgraph/providers/ollama-tools.ts

@@ -0,0 +1,52 @@
+/**
+ * Ollama tool calling support --- extracted from OllamaProvider.
+ */
+
+import type { LlmMessage, LlmOptions, LlmResponse, LlmToolCall } from "../llm-provider";
+import type { McpToolDefinition } from "../tool-registry";
+
+export async function ollamaChatWithTools(
+  baseUrl: string,
+  defaultModel: string,
+  messages: LlmMessage[],
+  tools: McpToolDefinition[],
+  options?: LlmOptions,
+  formatMessages?: (msgs: LlmMessage[]) => Array<{ role: string; content: string }>
+): Promise<LlmResponse> {
+  const model = options?.model || defaultModel;
+  const url = `${baseUrl}/api/chat`;
+  const ollamaTools = tools.map((t) => ({
+    type: "function" as const,
+    function: { name: t.name, description: t.description, parameters: t.inputSchema },
+  }));
+  const body: Record<string, unknown> = {
+    model,
+    messages: formatMessages ? formatMessages(messages) : messages.map(m => ({ role: m.role, content: m.content })),
+    tools: ollamaTools,
+    stream: false,
+  };
+  if (options?.temperature !== undefined) { body.options = { temperature: options.temperature }; }
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+    signal: options?.signal,
+  });
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => "Unknown error");
+    throw new Error(`Ollama API error ${response.status}: ${errorText}`);
+  }
+  const data = await response.json() as {
+    message?: { content?: string; tool_calls?: Array<{ function: { name: string; arguments: Record<string, unknown> } }> };
+  };
+  const toolCalls = data.message?.tool_calls;
+  if (toolCalls && toolCalls.length > 0) {
+    const calls: LlmToolCall[] = toolCalls.map((tc, idx) => ({
+      id: `ollama-tc-${Date.now()}-${idx}`,
+      name: tc.function.name,
+      arguments: tc.function.arguments,
+    }));
+    return { type: "tool_use", toolCalls: calls };
+  }
+  return { type: "text", text: data.message?.content || "" };
+}