kc-beta 0.1.1 → 0.2.1

package/src/agent/llm-client.js

@@ -1,102 +1,268 @@
+import { withRetry } from "./retry.js";
+
 /**
- * Thin LLM client using native fetch + SSE parsing.
- * Replaces the Python openai.AsyncOpenAI client.
- * Supports OpenAI-compatible APIs (SiliconFlow, Aliyun, OpenAI, etc.)
+ * Multi-protocol LLM client using native fetch + SSE parsing.
+ * Supports OpenAI-compatible APIs and Anthropic Messages API.
  */
 export class LLMClient {
   /**
    * @param {object} opts
    * @param {string} opts.apiKey
-   * @param {string} opts.baseUrl - e.g. "https://api.siliconflow.cn/v1"
+   * @param {string} opts.baseUrl - e.g. "https://api.siliconflow.cn/v1" or "https://api.anthropic.com"
+   * @param {string} [opts.authType] - "bearer" (default) | "x-api-key" (Anthropic)
+   * @param {string} [opts.apiFormat] - "openai" (default) | "anthropic"
    */
-  constructor({ apiKey, baseUrl }) {
+  constructor({ apiKey, baseUrl, authType = "bearer", apiFormat = "openai" }) {
     this.apiKey = apiKey;
     this.baseUrl = baseUrl.replace(/\/+$/, "");
+    this.authType = authType;
+    this.apiFormat = apiFormat;
   }
 
   /**
-   * Streaming chat completion. Yields parsed SSE chunk objects.
+   * Build auth headers based on provider type.
+   * @returns {object}
+   */
+  _buildHeaders() {
+    const headers = { "Content-Type": "application/json" };
+    if (this.authType === "x-api-key") {
+      headers["x-api-key"] = this.apiKey;
+      headers["anthropic-version"] = "2023-06-01";
+    } else if (this.authType === "aws-sigv4") {
+      throw new Error(
+        "AWS Bedrock authentication (SigV4) is not yet supported. " +
+        "Please use a different provider or an OpenAI-compatible proxy."
+      );
+    } else {
+      headers["Authorization"] = `Bearer ${this.apiKey}`;
+    }
+    return headers;
+  }
+
+  /**
+   * Get the chat endpoint for the configured API format.
+   * @returns {string}
+   */
+  _getEndpoint() {
+    if (this.apiFormat === "anthropic") {
+      return `${this.baseUrl}/v1/messages`;
+    }
+    return `${this.baseUrl}/chat/completions`;
+  }
+
+  /**
+   * Build request body for the configured API format.
    * @param {object} opts
-   * @param {string} opts.model
-   * @param {Array} opts.messages
-   * @param {Array} [opts.tools]
-   * @param {number} [opts.maxTokens]
-   * @yields {object} Parsed chunk from the SSE stream
+   * @returns {object}
    */
-  async *streamChat({ model, messages, tools, maxTokens }) {
-    const body = {
-      model,
-      messages,
-      stream: true,
-    };
+  _buildStreamBody({ model, messages, tools, maxTokens }) {
+    if (this.apiFormat === "anthropic") {
+      return this._buildAnthropicBody({ model, messages, tools, maxTokens, stream: true });
+    }
+    return this._buildOpenaiBody({ model, messages, tools, maxTokens, stream: true });
+  }
+
+  _buildNonStreamBody({ model, messages, maxTokens }) {
+    if (this.apiFormat === "anthropic") {
+      return this._buildAnthropicBody({ model, messages, tools: null, maxTokens, stream: false });
+    }
+    return this._buildOpenaiBody({ model, messages, tools: null, maxTokens, stream: false });
+  }
+
+  _buildOpenaiBody({ model, messages, tools, maxTokens, stream }) {
+    const body = { model, messages, stream };
     if (maxTokens) body.max_tokens = maxTokens;
     if (tools && tools.length > 0) body.tools = tools;
+    return body;
+  }
 
-    const resp = await fetch(`${this.baseUrl}/chat/completions`, {
-      method: "POST",
-      headers: {
-        "Authorization": `Bearer ${this.apiKey}`,
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify(body),
-    });
-
-    if (!resp.ok) {
-      const text = await resp.text();
-      throw new Error(`LLM API error ${resp.status}: ${text}`);
+  _buildAnthropicBody({ model, messages, tools, maxTokens, stream }) {
+    // Anthropic: system message is a top-level field, not in messages array
+    let system = undefined;
+    const filteredMessages = [];
+    for (const msg of messages) {
+      if (msg.role === "system") {
+        system = (system ? system + "\n\n" : "") + msg.content;
+      } else if (msg.role === "tool") {
+        // Anthropic expects tool results as user messages with tool_result content blocks
+        filteredMessages.push({
+          role: "user",
+          content: [{
+            type: "tool_result",
+            tool_use_id: msg.tool_call_id,
+            content: msg.content,
+          }],
+        });
+      } else if (msg.role === "assistant" && msg.tool_calls) {
+        // Convert OpenAI tool_calls to Anthropic content blocks
+        const content = [];
+        if (msg.content) content.push({ type: "text", text: msg.content });
+        for (const tc of msg.tool_calls) {
+          let input = {};
+          try { input = JSON.parse(tc.function.arguments || "{}"); } catch { /* ignore */ }
+          content.push({
+            type: "tool_use",
+            id: tc.id,
+            name: tc.function.name,
+            input,
+          });
+        }
+        filteredMessages.push({ role: "assistant", content });
+      } else {
+        filteredMessages.push(msg);
+      }
     }
 
-    for await (const data of this._parseSSE(resp.body)) {
-      yield data;
+    const body = {
+      model,
+      messages: filteredMessages,
+      max_tokens: maxTokens || 8192,
+      stream,
+    };
+    if (system) body.system = system;
+    if (tools && tools.length > 0) {
+      // Convert OpenAI tool schema to Anthropic tool schema
+      body.tools = tools.map((t) => ({
+        name: t.function.name,
+        description: t.function.description || "",
+        input_schema: t.function.parameters || { type: "object", properties: {} },
+      }));
     }
+    return body;
   }
 
   /**
-   * Non-streaming chat completion. Returns the full response.
+   * Streaming chat completion. Yields parsed SSE chunk objects
+   * normalized to OpenAI shape: { choices: [{ delta: { content?, tool_calls? } }] }
    * @param {object} opts
    * @param {string} opts.model
    * @param {Array} opts.messages
+   * @param {Array} [opts.tools]
    * @param {number} [opts.maxTokens]
-   * @returns {object} The response object
+   * @yields {object} Normalized chunk
+   */
+  async *streamChat({ model, messages, tools, maxTokens }) {
+    const body = this._buildStreamBody({ model, messages, tools, maxTokens });
+
+    const resp = await withRetry(async () => {
+      const r = await fetch(this._getEndpoint(), {
+        method: "POST",
+        headers: this._buildHeaders(),
+        body: JSON.stringify(body),
+      });
+      if (!r.ok) {
+        const text = await r.text();
+        const err = new Error(`LLM API error ${r.status}: ${text}`);
+        err.status = r.status;
+        err.retryAfter = r.headers.get("retry-after");
+        throw err;
+      }
+      return r;
+    });
+
+    if (this.apiFormat === "anthropic") {
+      yield* this._parseAnthropicSSE(resp.body);
+    } else {
+      yield* this._parseOpenaiSSE(resp.body);
+    }
+  }
+
+  /**
+   * Non-streaming chat completion. Returns the full response
+   * normalized to OpenAI shape.
+   * @param {object} opts
+   * @returns {object}
    */
   async chat({ model, messages, maxTokens }) {
-    const body = {
-      model,
-      messages,
-    };
-    if (maxTokens) body.max_tokens = maxTokens;
+    const body = this._buildNonStreamBody({ model, messages, maxTokens });
 
-    const resp = await fetch(`${this.baseUrl}/chat/completions`, {
-      method: "POST",
-      headers: {
-        "Authorization": `Bearer ${this.apiKey}`,
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify(body),
+    const resp = await withRetry(async () => {
+      const r = await fetch(this._getEndpoint(), {
+        method: "POST",
+        headers: this._buildHeaders(),
+        body: JSON.stringify(body),
+      });
+      if (!r.ok) {
+        const text = await r.text();
+        const err = new Error(`LLM API error ${r.status}: ${text}`);
+        err.status = r.status;
+        err.retryAfter = r.headers.get("retry-after");
+        throw err;
+      }
+      return r;
     });
 
-    if (!resp.ok) {
-      const text = await resp.text();
-      throw new Error(`LLM API error ${resp.status}: ${text}`);
+    const data = await resp.json();
+
+    if (this.apiFormat === "anthropic") {
+      // Normalize Anthropic response to OpenAI shape
+      const textParts = [];
+      for (const block of data.content || []) {
+        if (block.type === "text") textParts.push(block.text);
+      }
+      return {
+        choices: [{
+          message: {
+            role: "assistant",
+            content: textParts.join(""),
+          },
+        }],
+        usage: data.usage ? {
+          prompt_tokens: data.usage.input_tokens || 0,
+          completion_tokens: data.usage.output_tokens || 0,
+        } : undefined,
+      };
     }
 
-    return resp.json();
+    return data;
   }
 
   /**
-   * Parse SSE stream from a ReadableStream.
-   * Handles the `data: {...}` format used by OpenAI-compatible APIs.
+   * List available models from the provider.
+   * @returns {Promise<Array<{id: string, name: string, ownedBy: string}>>}
+   */
+  async listModels() {
+    let endpoint;
+    if (this.apiFormat === "anthropic") {
+      endpoint = `${this.baseUrl}/v1/models`;
+    } else {
+      endpoint = `${this.baseUrl}/models`;
+    }
+
+    try {
+      const resp = await fetch(endpoint, {
+        method: "GET",
+        headers: this._buildHeaders(),
+        signal: AbortSignal.timeout(5000),
+      });
+
+      if (!resp.ok) return [];
+      const data = await resp.json();
+      return (data.data || []).map((m) => ({
+        id: m.id,
+        name: m.id,
+        ownedBy: m.owned_by || "",
+      }));
+    } catch {
+      return [];
+    }
+  }
+
+  // --- OpenAI SSE parsing ---
+
+  /**
+   * Parse SSE stream from OpenAI-compatible API.
    * @param {ReadableStream} body
-   * @yields {object} Parsed JSON from each data line
+   * @yields {object} Parsed chunk
    */
-  async *_parseSSE(body) {
+  async *_parseOpenaiSSE(body) {
     const decoder = new TextDecoder();
     let buffer = "";
 
     for await (const chunk of body) {
       buffer += decoder.decode(chunk, { stream: true });
       const lines = buffer.split("\n");
-      buffer = lines.pop(); // keep incomplete line
+      buffer = lines.pop();
 
       for (const line of lines) {
         const trimmed = line.trim();
@@ -113,19 +279,146 @@ export class LLMClient {
       }
     }
 
-    // Process any remaining buffer
     if (buffer.trim()) {
       const trimmed = buffer.trim();
       if (trimmed.startsWith("data: ")) {
         const data = trimmed.slice(6).trim();
         if (data !== "[DONE]") {
-          try {
-            yield JSON.parse(data);
-          } catch {
-            // Skip
+          try { yield JSON.parse(data); } catch { /* skip */ }
+        }
+      }
+    }
+  }
+
+  // --- Anthropic SSE parsing + normalization ---
+
+  /**
+   * Parse Anthropic SSE stream and normalize to OpenAI chunk shape.
+   * Anthropic SSE uses event types: message_start, content_block_start,
+   * content_block_delta, content_block_stop, message_delta, message_stop.
+   *
+   * Normalizes everything to: { choices: [{ delta: { content?, tool_calls? } }] }
+   * so engine.js needs no changes.
+   *
+   * @param {ReadableStream} body
+   * @yields {object} Normalized OpenAI-shaped chunk
+   */
+  async *_parseAnthropicSSE(body) {
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let currentEventType = "";
+
+    // State for accumulating tool call content blocks
+    let toolCallIndex = -1;
+
+    for await (const rawChunk of body) {
+      buffer += decoder.decode(rawChunk, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop();
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith(":")) continue;
+
+        if (trimmed.startsWith("event: ")) {
+          currentEventType = trimmed.slice(7).trim();
+          continue;
+        }
+
+        if (trimmed.startsWith("data: ")) {
+          const dataStr = trimmed.slice(6).trim();
+          let data;
+          try { data = JSON.parse(dataStr); } catch { continue; }
+
+          const normalized = this._normalizeAnthropicEvent(currentEventType, data, { toolCallIndex });
+          if (normalized) {
+            // Update tool call index tracking
+            if (normalized._newToolCallIndex !== undefined) {
+              toolCallIndex = normalized._newToolCallIndex;
+              delete normalized._newToolCallIndex;
+            }
+            yield normalized;
           }
         }
       }
     }
   }
+
+  /**
+   * Normalize a single Anthropic SSE event into OpenAI chunk shape.
+   * @param {string} eventType
+   * @param {object} data
+   * @param {object} state - Mutable state for tracking across events
+   * @returns {object|null} Normalized chunk or null if no output needed
+   */
+  _normalizeAnthropicEvent(eventType, data, state) {
+    switch (eventType) {
+      case "content_block_start": {
+        const block = data.content_block;
+        if (block?.type === "text") {
+          // Text block starting — no content yet
+          return null;
+        }
+        if (block?.type === "tool_use") {
+          state.toolCallIndex++;
+          const chunk = {
+            choices: [{
+              delta: {
+                tool_calls: [{
+                  index: state.toolCallIndex,
+                  id: block.id,
+                  type: "function",
+                  function: { name: block.name, arguments: "" },
+                }],
+              },
+            }],
+            _newToolCallIndex: state.toolCallIndex,
+          };
+          return chunk;
+        }
+        return null;
+      }
+
+      case "content_block_delta": {
+        const delta = data.delta;
+        if (delta?.type === "text_delta") {
+          return {
+            choices: [{ delta: { content: delta.text } }],
+          };
+        }
+        if (delta?.type === "input_json_delta") {
+          return {
+            choices: [{
+              delta: {
+                tool_calls: [{
+                  index: state.toolCallIndex,
+                  function: { arguments: delta.partial_json },
+                }],
+              },
+            }],
+          };
+        }
+        return null;
+      }
+
+      case "message_delta": {
+        // End of message — contains stop_reason and usage
+        return {
+          choices: [{
+            delta: {},
+            finish_reason: data.delta?.stop_reason === "end_turn" ? "stop" : (data.delta?.stop_reason || null),
+          }],
+        };
+      }
+
+      case "message_start":
+      case "content_block_stop":
+      case "message_stop":
+      case "ping":
+        return null;
+
+      default:
+        return null;
+    }
+  }
 }

package/src/agent/pipelines/_archive_v1/distillation.js

@@ -0,0 +1,113 @@
+import fs from "node:fs";
+import path from "node:path";
+import { Phase, PipelineEvent } from "./index.js";
+import { Pipeline } from "./base.js";
+
+export class DistillationEngine extends Pipeline {
+  constructor(workspace) {
+    super();
+    this._workspace = workspace;
+    this.skillsToDistill = [];
+    this.workflowsCreated = {};
+    this.workflowsTested = {};
+    this.workflowsPassing = [];
+    this.tierAssignments = {};
+    this._workflowAccuracy = 0.9;
+    this._scanWorkspace();
+  }
+
+  _scanWorkspace() {
+    this._loadConfig();
+    this._loadSkills();
+    this._scanWorkflows();
+  }
+
+  _loadConfig() {
+    const envPath = path.join(this._workspace.cwd, ".env");
+    if (!fs.existsSync(envPath)) return;
+    for (const line of fs.readFileSync(envPath, "utf-8").split("\n")) {
+      if (line.startsWith("WORKFLOW_ACCURACY=")) try { this._workflowAccuracy = parseFloat(line.split("=")[1]); } catch { /* skip */ }
+    }
+  }
+
+  _loadSkills() {
+    this.skillsToDistill = [];
+    const dir = path.join(this._workspace.cwd, "rule_skills");
+    if (!fs.existsSync(dir)) return;
+    for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (e.isDirectory() && !e.name.startsWith("__")) this.skillsToDistill.push(e.name);
+    }
+  }
+
+  _scanWorkflows() {
+    this.workflowsCreated = {};
+    this.workflowsTested = {};
+    this.workflowsPassing = [];
+    this.tierAssignments = {};
+    const wfDir = path.join(this._workspace.cwd, "workflows");
+    if (!fs.existsSync(wfDir)) return;
+
+    for (const e of fs.readdirSync(wfDir, { withFileTypes: true })) {
+      if (e.isDirectory()) {
+        const ruleDir = path.join(wfDir, e.name);
+        const pyFiles = fs.readdirSync(ruleDir).filter((f) => f.endsWith(".py"));
+        if (pyFiles.length > 0) this.workflowsCreated[e.name] = pyFiles.length;
+        const cfgPath = path.join(ruleDir, "config.json");
+        if (fs.existsSync(cfgPath)) {
+          try {
+            const cfg = JSON.parse(fs.readFileSync(cfgPath, "utf-8"));
+            if (cfg.tier) this.tierAssignments[e.name] = cfg.tier;
+            if (cfg.accuracy != null) {
+              const acc = parseFloat(cfg.accuracy);
+              this.workflowsTested[e.name] = acc;
+              if (acc >= this._workflowAccuracy) this.workflowsPassing.push(e.name);
+            }
+          } catch { /* skip */ }
+        }
+      } else if (e.isFile() && e.name.endsWith(".py")) {
+        this.workflowsCreated[path.parse(e.name).name] = 1;
+      }
+    }
+  }
+
+  describeState() {
+    this._scanWorkspace();
+    const total = this.skillsToDistill.length;
+    const created = Object.keys(this.workflowsCreated).length;
+    const passing = this.workflowsPassing.length;
+    const parts = ["## Current Phase: DISTILLATION"];
+    parts.push(`### Progress\n- Skills to distill: ${total}\n- Workflows created: ${created}\n- Workflows passing (>=${this._workflowAccuracy}): ${passing}`);
+
+    if (this.exitCriteriaMet()) {
+      parts.push("### Ready\nAll workflows passing. Proceed to PRODUCTION_QC.");
+    } else if (created === 0) {
+      parts.push("### What to do now\nConvert proven skills into worker LLM workflows.\nFor each skill: write workflow script, write prompts, test vs ground truth, tier-downgrade test.");
+    } else {
+      const notCreated = this.skillsToDistill.filter((s) => !(s in this.workflowsCreated));
+      const notPassing = Object.keys(this.workflowsCreated).filter((s) => !this.workflowsPassing.includes(s));
+      let guidance = "### What to do now\n";
+      if (notCreated.length) guidance += `Create workflows for: ${notCreated.slice(0, 10).join(", ")}\n`;
+      if (notPassing.length) guidance += `Improve accuracy for: ${notPassing.slice(0, 10).join(", ")}\n`;
+      parts.push(guidance);
+    }
+    return parts.join("\n\n");
+  }
+
+  onToolResult(toolName, toolInput, result) {
+    if (result.isError) return null;
+    const wasReady = this.exitCriteriaMet();
+    if (toolName === "workspace_file" && ((toolInput.path || "").includes("workflows/") || (toolInput.path || "").includes("output/"))) {
+      this._scanWorkflows();
+    }
+    if (!wasReady && this.exitCriteriaMet()) {
+      return new PipelineEvent({ type: "phase_ready", message: "Distillation complete. Ready for PRODUCTION_QC.", nextPhase: Phase.PRODUCTION_QC });
+    }
+    return null;
+  }
+
+  exitCriteriaMet() {
+    const total = this.skillsToDistill.length;
+    if (!total) return false;
+    return Object.keys(this.workflowsCreated).length >= total && this.workflowsPassing.length >= total;
+  }
+}

package/src/agent/pipelines/_archive_v1/extraction.js

@@ -0,0 +1,92 @@
+import fs from "node:fs";
+import path from "node:path";
+import { Phase, PipelineEvent } from "./index.js";
+import { Pipeline } from "./base.js";
+
+export class RuleExtractionPipeline extends Pipeline {
+  constructor(workspace) {
+    super();
+    this._workspace = workspace;
+    this.regulationsScanned = false;
+    this.rulesExtracted = [];
+    this.rulesWithTests = [];
+    this.coverageAudited = false;
+    this._scanWorkspace();
+  }
+
+  _scanWorkspace() {
+    const rulesDir = path.join(this._workspace.cwd, "rules");
+    if (fs.existsSync(rulesDir)) {
+      const regFiles = fs.readdirSync(rulesDir).filter((f) => !f.endsWith(".json") && fs.statSync(path.join(rulesDir, f)).isFile());
+      this.regulationsScanned = regFiles.length > 0;
+    }
+    this._scanRules();
+    this._scanTests();
+    this.coverageAudited = fs.existsSync(path.join(this._workspace.cwd, "rules", "coverage_audit.md")) ||
+                           fs.existsSync(path.join(this._workspace.cwd, "rules", "coverage_audit.json"));
+  }
+
+  _scanRules() {
+    this.rulesExtracted = [];
+    const catalogPath = path.join(this._workspace.cwd, "rules", "catalog.json");
+    if (fs.existsSync(catalogPath)) {
+      try {
+        const data = JSON.parse(fs.readFileSync(catalogPath, "utf-8"));
+        if (Array.isArray(data)) this.rulesExtracted = data.map((r, i) => r.id || `rule_${i}`);
+      } catch { /* skip */ }
+    }
+    const skillsDir = path.join(this._workspace.cwd, "rule_skills");
+    if (fs.existsSync(skillsDir)) {
+      for (const e of fs.readdirSync(skillsDir, { withFileTypes: true })) {
+        if (e.isDirectory() && !e.name.startsWith("__") && !this.rulesExtracted.includes(e.name)) {
+          this.rulesExtracted.push(e.name);
+        }
+      }
+    }
+  }
+
+  _scanTests() {
+    this.rulesWithTests = [];
+    const skillsDir = path.join(this._workspace.cwd, "rule_skills");
+    if (!fs.existsSync(skillsDir)) return;
+    for (const e of fs.readdirSync(skillsDir, { withFileTypes: true })) {
+      if (!e.isDirectory()) continue;
+      const testDir = path.join(skillsDir, e.name, "test_cases");
+      if (fs.existsSync(testDir) && fs.readdirSync(testDir).length > 0) {
+        this.rulesWithTests.push(e.name);
+      }
+    }
+  }
+
+  describeState() {
+    this._scanWorkspace();
+    const parts = ["## Current Phase: EXTRACTION"];
+    parts.push(`### Progress\n- Regulations scanned: ${this.regulationsScanned ? "yes" : "no"}\n- Rules extracted: ${this.rulesExtracted.length}\n- Rules with tests: ${this.rulesWithTests.length}\n- Coverage audit: ${this.coverageAudited ? "done" : "not yet"}`);
+
+    if (this.exitCriteriaMet()) {
+      parts.push("### Ready\nExtraction complete. Proceed to SKILL_AUTHORING phase.");
+    } else if (this.rulesExtracted.length === 0) {
+      parts.push("### What to do now\nDecompose regulations into atomic, testable rules.\n- One rule = one pass/fail outcome\n- Work top-down: major areas → chapters → sections → atomic rules\n- Save rules to rules/catalog.json via rule_catalog tool");
+    } else if (!this.coverageAudited) {
+      parts.push("### What to do now\nRun a coverage audit: which regulation sections are NOT covered? Save to rules/coverage_audit.md");
+    }
+    return parts.join("\n\n");
+  }
+
+  onToolResult(toolName, toolInput, result) {
+    if (result.isError) return null;
+    const wasReady = this.exitCriteriaMet();
+    if (toolName === "workspace_file" || toolName === "rule_catalog") {
+      this._scanWorkspace();
+    }
+    if (!wasReady && this.exitCriteriaMet()) {
+      return new PipelineEvent({ type: "phase_ready", message: "Extraction complete. Ready for SKILL_AUTHORING.", nextPhase: Phase.SKILL_AUTHORING });
+    }
+    return null;
+  }
+
+  exitCriteriaMet() {
+    return this.regulationsScanned && this.rulesExtracted.length > 0 &&
+      this.rulesWithTests.length >= Math.max(this.rulesExtracted.length * 0.8, 1) && this.coverageAudited;
+  }
+}