sdlc-agent-4-enterprise-server 1.0.0

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

@@ -0,0 +1,151 @@
+/**
+ * OnnxProvider --- KSA-223
+ * CPU-only local LLM provider using ONNX Runtime.
+ * Extends BaseLlmProvider; overrides isAvailable() directly (file-based, not HTTP).
+ */
+import * as path from "path";
+import type { LlmMessage, LlmOptions } from "../llm-provider";
+import { BaseLlmProvider } from "./BaseLlmProvider";
+import { OnnxTokenizer } from "./onnx-tokenizer";
+
+const DEFAULT_MODEL_ID = "phi-3-mini";
+const MAX_CONTEXT_TOKENS = 2048;
+const MAX_NEW_TOKENS = 512;
+
+export interface OnnxModelConfig {
+  id: string;
+  displayName: string;
+  files: string[];
+  tokenizerFile: string;
+  modelFile: string;
+  contextLength: number;
+}
+
+export const ONNX_MODEL_REGISTRY: OnnxModelConfig[] = [
+  { id: "phi-3-mini", displayName: "Phi-3 Mini (3.8B, Q4)", files: ["model.onnx", "model.onnx.data", "tokenizer.json", "tokenizer_config.json"], tokenizerFile: "tokenizer.json", modelFile: "model.onnx", contextLength: 2048 },
+  { id: "smollm2-360m", displayName: "SmolLM2 (360M, FP16)", files: ["model.onnx", "tokenizer.json", "tokenizer_config.json"], tokenizerFile: "tokenizer.json", modelFile: "model.onnx", contextLength: 2048 },
+];
+
+export class OnnxProvider extends BaseLlmProvider {
+  readonly type = "ollama" as const; // kept for backward compat
+  private session: any = null;
+  private tokenizer: OnnxTokenizer | null = null;
+  private readonly modelDir: string;
+  private readonly modelId: string;
+
+  constructor(workspaceRoot: string, modelId?: string) {
+    super();
+    this.modelId = modelId || DEFAULT_MODEL_ID;
+    this.modelDir = path.join(workspaceRoot, ".code-intel", "models", "llm", this.modelId);
+    this.contextWindowTokens = MAX_CONTEXT_TOKENS;
+  }
+
+  async chat(messages: LlmMessage[], options?: LlmOptions): Promise<string> {
+    await this.ensureLoaded();
+    const prompt = this.formatPrompt(messages);
+    const inputIds = this.tokenizer!.encode(prompt);
+    const truncated = inputIds.slice(-Math.min(inputIds.length, MAX_CONTEXT_TOKENS));
+    const generated = await this.generate(truncated, options?.maxTokens || MAX_NEW_TOKENS, options?.temperature ?? 0.7);
+    return this.tokenizer!.decode(generated);
+  }
+
+  async *chatStream(messages: LlmMessage[], options?: LlmOptions): AsyncGenerator<string> {
+    await this.ensureLoaded();
+    const prompt = this.formatPrompt(messages);
+    const inputIds = this.tokenizer!.encode(prompt);
+    const truncated = inputIds.slice(-Math.min(inputIds.length, MAX_CONTEXT_TOKENS));
+    let currentIds = [...truncated];
+    const maxTokens = options?.maxTokens || MAX_NEW_TOKENS;
+    for (let i = 0; i < maxTokens; i++) {
+      const nextToken = await this.predictNext(currentIds, options?.temperature ?? 0.7);
+      if (nextToken === this.tokenizer!.eosTokenId) break;
+      currentIds.push(nextToken);
+      const text = this.tokenizer!.decode([nextToken]);
+      if (text) yield text;
+    }
+  }
+
+  /** Override isAvailable directly — file-based check, not HTTP */
+  async isAvailable(): Promise<boolean> {
+    try {
+      const fs = await import("fs");
+      const modelConfig = ONNX_MODEL_REGISTRY.find(m => m.id === this.modelId);
+      if (!modelConfig) return false;
+      return fs.existsSync(path.join(this.modelDir, modelConfig.modelFile));
+    } catch { return false; }
+  }
+
+  dispose(): void {
+    if (this.session) { this.session.release?.(); this.session = null; }
+    this.tokenizer = null;
+  }
+
+  // --- Abstract stubs (unused because isAvailable is overridden) ---
+  protected async isConfigured(): Promise<boolean> { return true; }
+  protected getHealthCheckUrl(): string { return ""; }
+
+  // --- Private helpers ---
+
+  private async ensureLoaded(): Promise<void> {
+    if (this.session && this.tokenizer) return;
+    const modelConfig = ONNX_MODEL_REGISTRY.find(m => m.id === this.modelId);
+    if (!modelConfig) { throw new Error(`Unknown ONNX model: ${this.modelId}`); }
+    this.tokenizer = await OnnxTokenizer.load(path.join(this.modelDir, modelConfig.tokenizerFile));
+    const ort = await import("onnxruntime-node" as string).catch(() => null);
+    if (!ort) { throw new Error("onnxruntime-node not available"); }
+    this.session = await ort.InferenceSession.create(
+      path.join(this.modelDir, modelConfig.modelFile),
+      { executionProviders: ["cpu"], graphOptimizationLevel: "all" },
+    );
+  }
+
+  private async generate(inputIds: number[], maxNewTokens: number, temperature: number): Promise<number[]> {
+    const generated: number[] = [];
+    let currentIds = [...inputIds];
+    for (let i = 0; i < maxNewTokens; i++) {
+      const nextToken = await this.predictNext(currentIds, temperature);
+      if (nextToken === this.tokenizer!.eosTokenId) break;
+      generated.push(nextToken);
+      currentIds.push(nextToken);
+    }
+    return generated;
+  }
+
+  private async predictNext(inputIds: number[], temperature: number): Promise<number> {
+    const ort = await import("onnxruntime-node" as string);
+    const inputTensor = new ort.Tensor("int64", BigInt64Array.from(inputIds.map(id => BigInt(id))), [1, inputIds.length]);
+    const attentionMask = new ort.Tensor("int64", BigInt64Array.from(inputIds.map(() => 1n)), [1, inputIds.length]);
+    const results = await this.session.run({ input_ids: inputTensor, attention_mask: attentionMask });
+    const logits = results.logits?.data || results[Object.keys(results)[0]]?.data;
+    if (!logits) throw new Error("ONNX model did not return logits");
+    const lastTokenLogits = Array.from(logits).slice(-this.tokenizer!.vocabSize) as number[];
+    return this.sample(lastTokenLogits, temperature);
+  }
+
+  private sample(logits: number[], temperature: number): number {
+    if (temperature <= 0.01) return logits.indexOf(Math.max(...logits));
+    const scaled = logits.map(l => l / temperature);
+    const maxLogit = Math.max(...scaled);
+    const exps = scaled.map(l => Math.exp(l - maxLogit));
+    const sumExps = exps.reduce((a, b) => a + b, 0);
+    const probs = exps.map(e => e / sumExps);
+    const rand = Math.random();
+    let cumulative = 0;
+    for (let i = 0; i < probs.length; i++) {
+      cumulative += probs[i];
+      if (rand < cumulative) return i;
+    }
+    return probs.length - 1;
+  }
+
+  private formatPrompt(messages: LlmMessage[]): string {
+    return messages.map(m => {
+      switch (m.role) {
+        case "system": return `<|system|>\n${m.content}<|end|>`;
+        case "user": return `<|user|>\n${m.content}<|end|>`;
+        case "assistant": return `<|assistant|>\n${m.content}<|end|>`;
+        default: return m.content;
+      }
+    }).join("\n") + "\n<|assistant|>\n";
+  }
+}

package/extension/src/langgraph/providers/onnx-tokenizer.ts

@@ -0,0 +1,47 @@
+/**
+ * OnnxTokenizer --- simple tokenizer for ONNX models.
+ */
+
+export class OnnxTokenizer {
+  private vocab: Map<string, number>;
+  private reverseVocab: Map<number, string>;
+  readonly vocabSize: number;
+  readonly eosTokenId: number;
+
+  private constructor(vocab: Map<string, number>, eosTokenId: number) {
+    this.vocab = vocab;
+    this.reverseVocab = new Map(Array.from(vocab.entries()).map(([k, v]) => [v, k]));
+    this.vocabSize = vocab.size;
+    this.eosTokenId = eosTokenId;
+  }
+
+  static async load(tokenizerPath: string): Promise<OnnxTokenizer> {
+    const fs = await import("fs");
+    const raw = fs.readFileSync(tokenizerPath, "utf-8");
+    const config = JSON.parse(raw);
+    const vocab = new Map<string, number>();
+    const model = config.model || {};
+    if (model.vocab) {
+      for (const [token, id] of Object.entries(model.vocab)) { vocab.set(token, id as number); }
+    } else if (config.added_tokens) {
+      for (const token of config.added_tokens) { vocab.set(token.content, token.id); }
+    }
+    const eosId = vocab.get("<|end|>") ?? vocab.get("</s>") ?? vocab.get("<|endoftext|>") ?? 0;
+    return new OnnxTokenizer(vocab, eosId);
+  }
+
+  encode(text: string): number[] {
+    const tokens: number[] = [];
+    const words = text.split(/(\s+)/);
+    for (const word of words) {
+      const id = this.vocab.get(word);
+      if (id !== undefined) { tokens.push(id); }
+      else { for (const char of word) { tokens.push(this.vocab.get(char) ?? 0); } }
+    }
+    return tokens;
+  }
+
+  decode(tokenIds: number[]): string {
+    return tokenIds.map(id => this.reverseVocab.get(id) || "").join("");
+  }
+}

package/extension/src/langgraph/providers/openai-helpers.ts

@@ -0,0 +1,38 @@
+/**
+ * OpenAI provider helpers — message formatting and header construction.
+ * Extracted from openai-provider.ts.
+ */
+
+export interface LlmMessageBasic { role: string; content: string; toolCallId?: string; }
+
+export function formatMessages(messages: LlmMessageBasic[]): Array<{ role: string; content: string }> {
+  return messages.map(m => ({ role: m.role, content: m.content }));
+}
+
+export function formatMessagesForTools(messages: LlmMessageBasic[]): any[] {
+  return messages.map((msg) => {
+    if (msg.role === "tool") {
+      return { role: "tool", tool_call_id: msg.toolCallId || "unknown", content: msg.content };
+    }
+    // Assistant message with tool_calls (from scratchpad)
+    if (msg.role === "assistant" && (msg as any).toolCalls) {
+      const toolCalls = (msg as any).toolCalls as Array<{ id: string; name: string; arguments: Record<string, unknown> }>;
+      return {
+        role: "assistant",
+        content: null,
+        tool_calls: toolCalls.map(tc => ({
+          id: tc.id,
+          type: "function",
+          function: { name: tc.name, arguments: JSON.stringify(tc.arguments) },
+        })),
+      };
+    }
+    return { role: msg.role, content: msg.content };
+  });
+}
+
+export function buildHeaders(apiKey: string): Record<string, string> {
+  const headers: Record<string, string> = { "Content-Type": "application/json" };
+  if (apiKey) { headers["Authorization"] = `Bearer ${apiKey}`; }
+  return headers;
+}

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

@@ -0,0 +1,168 @@
+/**
+ * OpenAIProvider — KSA-210. LLM provider using OpenAI Chat Completions API via fetch().
+ * Extends BaseLlmProvider for shared availability check and streaming.
+ */
+import type { LlmMessage, LlmOptions, LlmResponse, LlmToolCall } from "../llm-provider";
+import type { McpToolDefinition } from "../tool-registry";
+import { BaseLlmProvider } from "./BaseLlmProvider";
+import { formatMessages, formatMessagesForTools, buildHeaders } from "./openai-helpers";
+
+export const OPENAI_SECRET_KEY = "kiroSdlc.openaiApiKey";
+const DEFAULT_MODEL = "gpt-4o";
+const DEFAULT_MAX_TOKENS = 4096;
+const DEFAULT_API_BASE = "https://api.openai.com/v1";
+
+export class OpenAIProvider extends BaseLlmProvider {
+  readonly type = "openai" as const;
+  private readonly getApiKey: () => Promise<string | undefined>;
+  private readonly apiBase: string;
+
+  constructor(getApiKey: () => Promise<string | undefined>, baseUrl?: string) {
+    super();
+    this.getApiKey = getApiKey;
+    this.apiBase = (baseUrl || DEFAULT_API_BASE).replace(/\/$/, "");
+    // Set context window based on whether this is a local server (LM Studio) or cloud
+    this.contextWindowTokens = this.isLocalServer() ? 8192 : 128000;
+  }
+
+  /** Detect context window from /v1/models endpoint (LM Studio / local servers) */
+  async detectContextWindow(): Promise<void> {
+    if (!this.isLocalServer()) return; // Cloud providers have known limits
+    try {
+      const response = await fetch(`${this.apiBase}/models`, {
+        method: "GET",
+        signal: AbortSignal.timeout(5000),
+      });
+      if (response.ok) {
+        const data = await response.json() as { data?: Array<{ id: string; context_length?: number }> };
+        const model = data.data?.[0];
+        if (model?.context_length && model.context_length > 0) {
+          this.contextWindowTokens = model.context_length;
+        }
+      }
+    } catch { /* keep default */ }
+  }
+
+  async chat(messages: LlmMessage[], options?: LlmOptions): Promise<string> {
+    const apiKey = await this.requireApiKey();
+    const body = this.buildChatBody(messages, options, false);
+    const response = await fetch(`${this.apiBase}/chat/completions`, {
+      method: "POST", headers: buildHeaders(apiKey),
+      body: JSON.stringify(body), signal: options?.signal,
+    });
+    if (!response.ok) {
+      throw new Error(`OpenAI API error ${response.status}: ${await response.text().catch(() => "Unknown")}`);
+    }
+    const data = await response.json() as { choices?: Array<{ message?: { content?: string } }> };
+    return data.choices?.[0]?.message?.content || "";
+  }
+
+  async *chatStream(messages: LlmMessage[], options?: LlmOptions): AsyncGenerator<string> {
+    const apiKey = await this.requireApiKey();
+    const body = this.buildChatBody(messages, options, true);
+    const response = await fetch(`${this.apiBase}/chat/completions`, {
+      method: "POST", headers: buildHeaders(apiKey),
+      body: JSON.stringify(body), signal: options?.signal,
+    });
+    if (!response.ok) {
+      throw new Error(`OpenAI API error ${response.status}: ${await response.text().catch(() => "Unknown")}`);
+    }
+    yield* this.readStream(response, (parsed) => {
+      return parsed.choices?.[0]?.delta?.content || null;
+    });
+  }
+
+  async chatWithTools(messages: LlmMessage[], tools: McpToolDefinition[], options?: LlmOptions): Promise<LlmResponse> {
+    const apiKey = await this.requireApiKey();
+    const openaiTools = tools.map(t => ({
+      type: "function" as const,
+      function: { name: t.name, description: t.description, parameters: t.inputSchema },
+    }));
+    const body: Record<string, unknown> = {
+      model: options?.model || DEFAULT_MODEL,
+      messages: formatMessagesForTools(messages),
+      max_tokens: options?.maxTokens || DEFAULT_MAX_TOKENS,
+      tools: openaiTools,
+    };
+    if (options?.temperature !== undefined) { body.temperature = options.temperature; }
+    const response = await fetch(`${this.apiBase}/chat/completions`, {
+      method: "POST", headers: buildHeaders(apiKey),
+      body: JSON.stringify(body), signal: options?.signal,
+    });
+    if (!response.ok) {
+      throw new Error(`OpenAI API error ${response.status}: ${await response.text().catch(() => "Unknown")}`);
+    }
+    const data = await response.json() as {
+      choices?: Array<{ message?: { content?: string | null; tool_calls?: Array<{ id: string; function: { name: string; arguments: string } }> } }>
+    };
+    const toolCalls = data.choices?.[0]?.message?.tool_calls;
+    if (toolCalls && toolCalls.length > 0) {
+      const calls: LlmToolCall[] = toolCalls.map(tc => {
+        let args: Record<string, unknown> = {};
+        try { args = JSON.parse(tc.function.arguments); } catch { /* empty */ }
+        return { id: tc.id, name: tc.function.name, arguments: args };
+      });
+      return { type: "tool_use", toolCalls: calls };
+    }
+    return { type: "text", text: data.choices?.[0]?.message?.content || "" };
+  }
+
+  dispose(): void { /* stateless */ }
+
+  // --- Template Method hooks ---
+
+  protected async isConfigured(): Promise<boolean> {
+    const key = await this.getApiKey();
+    return !!(key || this.apiBase !== DEFAULT_API_BASE);
+  }
+
+  protected getHealthCheckUrl(): string {
+    const isLocal = this.isLocalServer();
+    return isLocal ? `${this.apiBase}/models` : `${this.apiBase}/chat/completions`;
+  }
+
+  protected getHealthCheckRequest() {
+    if (this.isLocalServer()) {
+      return { method: "GET" };
+    }
+    return {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: "gpt-4o-mini",
+        messages: [{ role: "user", content: "hi" }],
+        max_tokens: 1,
+      }),
+    };
+  }
+
+  protected isHealthyStatus(status: number): boolean {
+    if (this.isLocalServer()) return status === 200;
+    return status === 200 || status === 429;
+  }
+
+  // --- Private helpers ---
+
+  private isLocalServer(): boolean {
+    return this.apiBase !== DEFAULT_API_BASE;
+  }
+
+  private buildChatBody(messages: LlmMessage[], options: LlmOptions | undefined, stream: boolean): Record<string, unknown> {
+    const body: Record<string, unknown> = {
+      model: options?.model || DEFAULT_MODEL,
+      messages: formatMessages(messages),
+      max_tokens: options?.maxTokens || DEFAULT_MAX_TOKENS,
+      stream,
+    };
+    if (options?.temperature !== undefined) { body.temperature = options.temperature; }
+    return body;
+  }
+
+  private async requireApiKey(): Promise<string> {
+    const key = await this.getApiKey();
+    if (!key && this.apiBase === DEFAULT_API_BASE) {
+      throw new Error("OpenAI API key not configured.");
+    }
+    return key || "";
+  }
+}

package/extension/src/langgraph/providers/stream-handler.ts

@@ -0,0 +1,187 @@
+// StreamHandler --- KSA-231 --- SSE parser for Kiro API streaming responses
+
+export type StreamEvent =
+  | { type: "text"; text: string }
+  | { type: "tool_use"; id: string; name: string; input: Record<string, unknown> }
+  | { type: "message_stop"; usage?: { input_tokens: number; output_tokens: number } };
+
+
+export class StreamHandler {
+  async *processStream(
+    response: Response,
+    signal?: AbortSignal
+  ): AsyncGenerator<string> {
+    if (!response.body) {
+      throw new KiroStreamError("Response has no body for streaming");
+    }
+
+    const reader = (response.body as any).getReader() as ReadableStreamDefaultReader<Uint8Array>;
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let chunkCount = 0;
+
+    try {
+      while (true) {
+        if (signal?.aborted) {
+          await reader.cancel();
+          return;
+        }
+
+        const { done, value } = await reader.read();
+        if (done) { break; }
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed || !trimmed.startsWith("data: ")) { continue; }
+
+          const data = trimmed.slice(6);
+          if (data === "[DONE]") { return; }
+
+          try {
+            const parsed = JSON.parse(data);
+            const text = this.extractTextDelta(parsed);
+            if (text) {
+              yield text;
+              chunkCount++;
+
+              // Backpressure: yield microtask boundary every 100 chunks
+              if (chunkCount % 100 === 0) {
+                await Promise.resolve();
+              }
+            }
+
+            // Check for message_stop
+            if (parsed.type === "message_stop") { return; }
+          } catch {
+            // Skip malformed SSE data — continue processing
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+
+  async *processStreamWithToolUse(
+    response: Response,
+    signal?: AbortSignal
+  ): AsyncGenerator<StreamEvent> {
+    if (!response.body) {
+      throw new KiroStreamError("Response has no body for streaming");
+    }
+
+    const reader = (response.body as any).getReader() as ReadableStreamDefaultReader<Uint8Array>;
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let chunkCount = 0;
+
+    // Track tool_use blocks being assembled
+    const toolBlocks = new Map<number, { id: string; name: string; jsonBuffer: string }>();
+
+    try {
+      while (true) {
+        if (signal?.aborted) {
+          await reader.cancel();
+          return;
+        }
+
+        const { done, value } = await reader.read();
+        if (done) { break; }
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed || !trimmed.startsWith("data: ")) { continue; }
+
+          const data = trimmed.slice(6);
+          if (data === "[DONE]") { return; }
+
+          try {
+            const parsed = JSON.parse(data);
+
+            // content_block_start for tool_use
+            if (parsed.type === "content_block_start" && parsed.content_block?.type === "tool_use") {
+              toolBlocks.set(parsed.index, {
+                id: parsed.content_block.id,
+                name: parsed.content_block.name,
+                jsonBuffer: "",
+              });
+              continue;
+            }
+
+            // content_block_delta for text
+            if (parsed.type === "content_block_delta" && parsed.delta?.type === "text_delta") {
+              const text = parsed.delta.text;
+              if (text) {
+                yield { type: "text", text };
+                chunkCount++;
+                if (chunkCount % 100 === 0) { await Promise.resolve(); }
+              }
+              continue;
+            }
+
+            // content_block_delta for tool_use input JSON
+            if (parsed.type === "content_block_delta" && parsed.delta?.type === "input_json_delta") {
+              const block = toolBlocks.get(parsed.index);
+              if (block) {
+                block.jsonBuffer += parsed.delta.partial_json || "";
+              }
+              continue;
+            }
+
+            // content_block_stop — emit tool_use if we were building one
+            if (parsed.type === "content_block_stop") {
+              const block = toolBlocks.get(parsed.index);
+              if (block) {
+                let input: Record<string, unknown> = {};
+                try { input = JSON.parse(block.jsonBuffer); } catch { /* empty */ }
+                yield { type: "tool_use", id: block.id, name: block.name, input };
+                toolBlocks.delete(parsed.index);
+              }
+              continue;
+            }
+
+            // message_delta — contains usage info
+            if (parsed.type === "message_delta") {
+              // We don't yield this — it comes before message_stop
+              continue;
+            }
+
+            // message_stop
+            if (parsed.type === "message_stop") {
+              yield { type: "message_stop", usage: parsed.usage };
+              return;
+            }
+          } catch {
+            // Skip malformed SSE data
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+
+
+  private extractTextDelta(parsed: any): string | null {
+    if (parsed.type === "content_block_delta" && parsed.delta?.type === "text_delta") {
+      return parsed.delta.text || null;
+    }
+    return null;
+  }
+}
+
+
+export class KiroStreamError extends Error {
+  constructor(message: string, options?: ErrorOptions) {
+    super(message, options);
+    this.name = "KiroStreamError";
+  }
+}