@stackmemoryai/stackmemory 1.0.1 → 1.2.0

package/dist/src/integrations/anthropic/batch-client.js

@@ -0,0 +1,256 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { logger } from "../../core/monitoring/logger.js";
+const BATCH_JOBS_PATH = join(homedir(), ".stackmemory", "batch-jobs.json");
+const DEFAULT_POLL_INTERVAL_MS = 3e4;
+const DEFAULT_TIMEOUT_MS = 2 * 60 * 60 * 1e3;
+class AnthropicBatchClient {
+  apiKey;
+  baseUrl;
+  mockMode;
+  constructor(config) {
+    this.apiKey = config?.apiKey !== void 0 ? config.apiKey : process.env["ANTHROPIC_API_KEY"] || "";
+    this.baseUrl = config?.baseUrl || "https://api.anthropic.com";
+    this.mockMode = config?.mockMode ?? !this.apiKey;
+    if (this.mockMode) {
+      logger.warn("AnthropicBatchClient: no API key, using mock mode");
+    }
+  }
+  /**
+   * Submit a batch of requests
+   */
+  async submit(requests, description) {
+    if (this.mockMode) {
+      const batchId = `batch_mock_${Date.now()}`;
+      this.persistJob({
+        batchId,
+        status: "ended",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        endedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        requestCount: requests.length,
+        description
+      });
+      return batchId;
+    }
+    const response = await fetch(`${this.baseUrl}/v1/messages/batches`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": this.apiKey,
+        "anthropic-version": "2023-06-01"
+      },
+      body: JSON.stringify({ requests })
+    });
+    if (!response.ok) {
+      const errText = await response.text();
+      throw new Error(`Batch submit failed: ${response.status} ${errText}`);
+    }
+    const job = await response.json();
+    this.persistJob({
+      batchId: job.id,
+      status: job.processing_status,
+      createdAt: job.created_at,
+      requestCount: requests.length,
+      description
+    });
+    logger.info("Batch submitted", { batchId: job.id, count: requests.length });
+    return job.id;
+  }
+  /**
+   * Poll batch job status
+   */
+  async poll(batchId) {
+    if (this.mockMode) {
+      return this.mockBatchJob(batchId);
+    }
+    const response = await fetch(
+      `${this.baseUrl}/v1/messages/batches/${batchId}`,
+      {
+        headers: {
+          "x-api-key": this.apiKey,
+          "anthropic-version": "2023-06-01"
+        }
+      }
+    );
+    if (!response.ok) {
+      const errText = await response.text();
+      throw new Error(`Batch poll failed: ${response.status} ${errText}`);
+    }
+    const job = await response.json();
+    this.updateJobStatus(batchId, job.processing_status, job.ended_at);
+    return job;
+  }
+  /**
+   * Retrieve batch results
+   */
+  async retrieve(batchId) {
+    if (this.mockMode) {
+      return this.mockBatchResults(batchId);
+    }
+    const job = await this.poll(batchId);
+    if (job.processing_status !== "ended") {
+      throw new Error(
+        `Batch ${batchId} not finished: ${job.processing_status}`
+      );
+    }
+    if (!job.results_url) {
+      throw new Error(`Batch ${batchId} has no results URL`);
+    }
+    const response = await fetch(job.results_url, {
+      headers: {
+        "x-api-key": this.apiKey,
+        "anthropic-version": "2023-06-01"
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`Batch retrieve failed: ${response.status}`);
+    }
+    const text = await response.text();
+    return text.trim().split("\n").filter(Boolean).map((line) => JSON.parse(line));
+  }
+  /**
+   * Poll until batch completes or times out
+   */
+  async waitForCompletion(batchId, timeoutMs = DEFAULT_TIMEOUT_MS, pollIntervalMs = DEFAULT_POLL_INTERVAL_MS) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      const job = await this.poll(batchId);
+      if (job.processing_status === "ended") {
+        return job;
+      }
+      const remaining = deadline - Date.now();
+      const waitTime = Math.min(pollIntervalMs, remaining);
+      if (waitTime <= 0) break;
+      await new Promise((resolve) => {
+        const timer = setTimeout(() => resolve(), waitTime);
+        if (typeof timer === "object" && "unref" in timer) {
+          timer.unref();
+        }
+      });
+    }
+    throw new Error(`Batch ${batchId} timed out after ${timeoutMs}ms`);
+  }
+  /**
+   * Submit and wait for results (convenience)
+   */
+  async submitAndWait(requests, timeoutMs = DEFAULT_TIMEOUT_MS, description) {
+    const batchId = await this.submit(requests, description);
+    await this.waitForCompletion(batchId, timeoutMs);
+    return this.retrieve(batchId);
+  }
+  /**
+   * Cancel a batch job
+   */
+  async cancel(batchId) {
+    if (this.mockMode) {
+      return this.mockBatchJob(batchId, "canceling");
+    }
+    const response = await fetch(
+      `${this.baseUrl}/v1/messages/batches/${batchId}/cancel`,
+      {
+        method: "POST",
+        headers: {
+          "x-api-key": this.apiKey,
+          "anthropic-version": "2023-06-01"
+        }
+      }
+    );
+    if (!response.ok) {
+      throw new Error(`Batch cancel failed: ${response.status}`);
+    }
+    const job = await response.json();
+    this.updateJobStatus(batchId, job.processing_status);
+    return job;
+  }
+  /**
+   * List stored batch jobs
+   */
+  listJobs() {
+    return this.loadStoredJobs();
+  }
+  // ── Persistence ───────────────────────────────────────────────────────
+  persistJob(job) {
+    const jobs = this.loadStoredJobs();
+    const existing = jobs.findIndex((j) => j.batchId === job.batchId);
+    if (existing >= 0) {
+      jobs[existing] = job;
+    } else {
+      jobs.push(job);
+    }
+    const trimmed = jobs.slice(-50);
+    this.saveStoredJobs(trimmed);
+  }
+  updateJobStatus(batchId, status, endedAt) {
+    const jobs = this.loadStoredJobs();
+    const job = jobs.find((j) => j.batchId === batchId);
+    if (job) {
+      job.status = status;
+      if (endedAt) job.endedAt = endedAt;
+      this.saveStoredJobs(jobs);
+    }
+  }
+  loadStoredJobs() {
+    try {
+      if (existsSync(BATCH_JOBS_PATH)) {
+        return JSON.parse(readFileSync(BATCH_JOBS_PATH, "utf8"));
+      }
+    } catch {
+    }
+    return [];
+  }
+  saveStoredJobs(jobs) {
+    try {
+      const dir = join(homedir(), ".stackmemory");
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+      }
+      writeFileSync(BATCH_JOBS_PATH, JSON.stringify(jobs, null, 2));
+    } catch {
+    }
+  }
+  // ── Mock mode ─────────────────────────────────────────────────────────
+  mockBatchJob(batchId, status = "ended") {
+    return {
+      id: batchId,
+      type: "message_batch",
+      processing_status: status,
+      request_counts: {
+        processing: 0,
+        succeeded: 1,
+        errored: 0,
+        canceled: 0,
+        expired: 0
+      },
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      ended_at: status === "ended" ? (/* @__PURE__ */ new Date()).toISOString() : void 0
+    };
+  }
+  mockBatchResults(batchId) {
+    const jobs = this.loadStoredJobs();
+    const job = jobs.find((j) => j.batchId === batchId);
+    const count = job?.requestCount || 1;
+    return Array.from({ length: count }, (_, i) => ({
+      custom_id: `req_${i}`,
+      result: {
+        type: "succeeded",
+        message: {
+          id: `msg_mock_${i}`,
+          content: [
+            { type: "text", text: `Mock batch response for request ${i}` }
+          ],
+          model: "claude-sonnet-4-5-20250929",
+          stop_reason: "end_turn",
+          usage: { input_tokens: 100, output_tokens: 50 }
+        }
+      }
+    }));
+  }
+}
+export {
+  AnthropicBatchClient
+};

package/dist/src/integrations/anthropic/client.js

@@ -3,6 +3,7 @@ import { dirname as __pathDirname } from 'path';
 const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
 import { logger } from "../../core/monitoring/logger.js";
+import { STRUCTURED_RESPONSE_SUFFIX } from "../../orchestrators/multimodal/constants.js";
 class AnthropicClient {
   apiKey;
   baseURL;
@@ -31,17 +32,21 @@ class AnthropicClient {
    * Send completion request to Claude
    */
   async complete(request) {
+    const enhancedRequest = {
+      ...request,
+      systemPrompt: request.systemPrompt + STRUCTURED_RESPONSE_SUFFIX
+    };
     await this.checkRateLimit();
     logger.debug("Sending completion request", {
-      model: request.model,
-      promptLength: request.prompt.length,
-      maxTokens: request.maxTokens
+      model: enhancedRequest.model,
+      promptLength: enhancedRequest.prompt.length,
+      maxTokens: enhancedRequest.maxTokens
     });
     if (!this.apiKey) {
-      return this.mockComplete(request);
+      return this.mockComplete(enhancedRequest);
     }
     try {
-      const response = await this.sendRequest(request);
+      const response = await this.sendRequest(enhancedRequest);
       return response.content;
     } catch (error) {
       logger.error("Anthropic API error", { error });
@@ -57,7 +62,9 @@ class AnthropicClient {
     } catch (error) {
       if (attempt < this.maxRetries) {
         const delay = Math.pow(2, attempt) * 1e3;
-        logger.warn(`Retrying after ${delay}ms (attempt ${attempt}/${this.maxRetries})`);
+        logger.warn(
+          `Retrying after ${delay}ms (attempt ${attempt}/${this.maxRetries})`
+        );
         await this.delay(delay);
         return this.sendRequest(request, attempt + 1);
       }
@@ -85,44 +92,48 @@ class AnthropicClient {
    * Mock response generators
    */
   mockPlanningResponse(prompt) {
-    return JSON.stringify({
-      plan: {
-        type: "sequential",
-        tasks: [
-          {
-            id: "task-1",
-            description: "Analyze requirements",
-            agent: "context",
-            dependencies: []
-          },
-          {
-            id: "task-2",
-            type: "parallel",
-            description: "Implementation phase",
-            children: [
-              {
-                id: "task-2a",
-                description: "Write core logic",
-                agent: "code",
-                dependencies: ["task-1"]
-              },
-              {
-                id: "task-2b",
-                description: "Write tests",
-                agent: "testing",
-                dependencies: ["task-1"]
-              }
-            ]
-          },
-          {
-            id: "task-3",
-            description: "Review and improve",
-            agent: "review",
-            dependencies: ["task-2"]
-          }
-        ]
-      }
-    }, null, 2);
+    return JSON.stringify(
+      {
+        plan: {
+          type: "sequential",
+          tasks: [
+            {
+              id: "task-1",
+              description: "Analyze requirements",
+              agent: "context",
+              dependencies: []
+            },
+            {
+              id: "task-2",
+              type: "parallel",
+              description: "Implementation phase",
+              children: [
+                {
+                  id: "task-2a",
+                  description: "Write core logic",
+                  agent: "code",
+                  dependencies: ["task-1"]
+                },
+                {
+                  id: "task-2b",
+                  description: "Write tests",
+                  agent: "testing",
+                  dependencies: ["task-1"]
+                }
+              ]
+            },
+            {
+              id: "task-3",
+              description: "Review and improve",
+              agent: "review",
+              dependencies: ["task-2"]
+            }
+          ]
+        }
+      },
+      null,
+      2
+    );
   }
   mockCodeResponse(prompt) {
     return `
@@ -166,34 +177,38 @@ describe('validateInput', () => {
     `.trim();
   }
   mockReviewResponse(prompt) {
-    return JSON.stringify({
-      quality: 0.75,
-      issues: [
-        "Missing error handling in processTask function",
-        "No input validation before processing",
-        "Tests could cover more edge cases"
-      ],
-      suggestions: [
-        "Add try-catch block in processTask",
-        "Validate input length and type",
-        "Add tests for special characters and long inputs",
-        "Consider adding performance tests"
-      ],
-      improvements: [
-        {
-          file: "implementation.ts",
-          line: 3,
-          suggestion: "Add input validation",
-          priority: "high"
-        },
-        {
-          file: "tests.ts",
-          line: 15,
-          suggestion: "Add edge case tests",
-          priority: "medium"
-        }
-      ]
-    }, null, 2);
+    return JSON.stringify(
+      {
+        quality: 0.75,
+        issues: [
+          "Missing error handling in processTask function",
+          "No input validation before processing",
+          "Tests could cover more edge cases"
+        ],
+        suggestions: [
+          "Add try-catch block in processTask",
+          "Validate input length and type",
+          "Add tests for special characters and long inputs",
+          "Consider adding performance tests"
+        ],
+        improvements: [
+          {
+            file: "implementation.ts",
+            line: 3,
+            suggestion: "Add input validation",
+            priority: "high"
+          },
+          {
+            file: "tests.ts",
+            line: 15,
+            suggestion: "Add edge case tests",
+            priority: "medium"
+          }
+        ]
+      },
+      null,
+      2
+    );
   }
   /**
    * Create mock response object

package/dist/src/integrations/claude-code/subagent-client.js

@@ -3,11 +3,21 @@ import { dirname as __pathDirname } from 'path';
 const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
 import { logger } from "../../core/monitoring/logger.js";
+import { STRUCTURED_RESPONSE_SUFFIX } from "../../orchestrators/multimodal/constants.js";
 import { exec } from "child_process";
 import { promisify } from "util";
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
+import { isFeatureEnabled } from "../../core/config/feature-flags.js";
+import {
+  getOptimalProvider
+} from "../../core/models/model-router.js";
+import { scoreComplexity } from "../../core/models/complexity-scorer.js";
+import {
+  createProvider
+} from "../../core/extensions/provider-adapter.js";
+import { AnthropicBatchClient } from "../anthropic/batch-client.js";
 const execAsync = promisify(exec);
 class ClaudeCodeSubagentClient {
   tempDir;
@@ -25,8 +35,9 @@ class ClaudeCodeSubagentClient {
     });
   }
   /**
-   * Execute a subagent task using Claude Code's Task tool
-   * This will spawn a new Claude instance with specific instructions
+   * Execute a subagent task.
+   * When multiProvider is enabled, routes cheap tasks to external providers.
+   * Falls back to Claude Code CLI path when disabled or for complex tasks.
    */
   async executeSubagent(request) {
     const startTime = Date.now();
@@ -39,6 +50,107 @@ class ClaudeCodeSubagentClient {
     if (this.mockMode) {
       return this.getMockResponse(request, startTime, subagentId);
     }
+    if (isFeatureEnabled("multiProvider")) {
+      const taskType = request.type;
+      const complexity = scoreComplexity(request.task, request.context);
+      const optimal = getOptimalProvider(taskType, void 0, {
+        task: request.task,
+        context: request.context
+      });
+      logger.debug("Complexity-based routing", {
+        subagentId,
+        taskType,
+        complexity: complexity.tier,
+        score: complexity.score,
+        signals: complexity.signals,
+        routed: optimal.provider
+      });
+      if (optimal.provider !== "anthropic" && optimal.provider !== "anthropic-batch") {
+        return this.executeDirectAPI(request, optimal, startTime, subagentId);
+      }
+      if (optimal.provider === "anthropic-batch") {
+        return this.executeBatch(request, startTime, subagentId);
+      }
+    }
+    return this.executeSubagentViaCLI(request, startTime, subagentId);
+  }
+  /**
+   * Execute via external provider (Cerebras, DeepInfra, etc.) using OpenAI-compatible API
+   */
+  async executeDirectAPI(request, optimal, startTime, subagentId) {
+    try {
+      const apiKey = process.env[optimal.apiKeyEnv] || "";
+      if (!apiKey) {
+        logger.warn(
+          `No API key for ${optimal.provider}, falling back to Claude`
+        );
+        return this.executeSubagentViaCLI(request, startTime, subagentId);
+      }
+      const adapter = createProvider(optimal.provider, {
+        apiKey,
+        baseUrl: optimal.baseUrl
+      });
+      const prompt = this.buildSubagentPrompt(request);
+      const result = await adapter.complete(
+        [{ role: "user", content: prompt }],
+        { model: optimal.model, maxTokens: 4096 }
+      );
+      const text = result.content.filter((c) => c.type === "text").map((c) => c.text).join("");
+      let parsed;
+      try {
+        parsed = JSON.parse(text);
+      } catch {
+        parsed = { rawOutput: text };
+      }
+      return {
+        success: true,
+        result: parsed,
+        output: text,
+        duration: Date.now() - startTime,
+        subagentType: request.type,
+        tokens: result.usage.inputTokens + result.usage.outputTokens
+      };
+    } catch (error) {
+      logger.warn(`Direct API failed for ${optimal.provider}, falling back`, {
+        error: error.message
+      });
+      return this.executeSubagentViaCLI(request, startTime, subagentId);
+    }
+  }
+  /**
+   * Execute via Anthropic Batch API (async, 50% discount)
+   */
+  async executeBatch(request, startTime, subagentId) {
+    try {
+      const batchClient = new AnthropicBatchClient();
+      const prompt = this.buildSubagentPrompt(request);
+      const batchReq = {
+        custom_id: subagentId,
+        params: {
+          model: "claude-sonnet-4-5-20250929",
+          max_tokens: 4096,
+          messages: [{ role: "user", content: prompt }]
+        }
+      };
+      const batchId = await batchClient.submit([batchReq], request.type);
+      return {
+        success: true,
+        result: { batchId, status: "submitted", custom_id: subagentId },
+        output: `Batch submitted: ${batchId}`,
+        duration: Date.now() - startTime,
+        subagentType: request.type
+      };
+    } catch (error) {
+      logger.warn("Batch submit failed, falling back to sync", {
+        error: error.message
+      });
+      return this.executeSubagentViaCLI(request, startTime, subagentId);
+    }
+  }
+  /**
+   * Original CLI-based subagent execution (unchanged behavior)
+   */
+  async executeSubagentViaCLI(request, startTime, subagentId) {
     try {
       const prompt = this.buildSubagentPrompt(request);
       const contextFile = path.join(this.tempDir, `${subagentId}-context.json`);
@@ -47,14 +159,19 @@ class ClaudeCodeSubagentClient {
         JSON.stringify(request.context, null, 2)
       );
       const resultFile = path.join(this.tempDir, `${subagentId}-result.json`);
-      const taskCommand = this.buildTaskCommand(request, prompt, contextFile, resultFile);
+      const taskCommand = this.buildTaskCommand(
+        request,
+        prompt,
+        contextFile,
+        resultFile
+      );
       const result = await this.executeTaskTool(taskCommand, request.timeout);
       let subagentResult = {};
       if (fs.existsSync(resultFile)) {
         const resultContent = await fs.promises.readFile(resultFile, "utf-8");
         try {
           subagentResult = JSON.parse(resultContent);
-        } catch (e) {
+        } catch {
           subagentResult = { rawOutput: resultContent };
         }
       }
@@ -68,7 +185,10 @@ class ClaudeCodeSubagentClient {
         tokens: this.estimateTokens(prompt + JSON.stringify(subagentResult))
       };
     } catch (error) {
-      logger.error(`Subagent execution failed: ${request.type}`, { error, subagentId });
+      logger.error(`Subagent CLI execution failed: ${request.type}`, {
+        error,
+        subagentId
+      });
       return {
         success: false,
         result: null,
@@ -224,7 +344,7 @@ class ClaudeCodeSubagentClient {
         
         Output the release plan and commands.`
     };
-    return request.systemPrompt || prompts[request.type] || prompts.planning;
+    return (request.systemPrompt || prompts[request.type] || prompts.planning) + STRUCTURED_RESPONSE_SUFFIX;
   }
   /**
    * Build Task tool command
@@ -292,7 +412,9 @@ echo '{"status": "completed", "type": "${request.type}"}' > "${resultFile}"
    * Get mock response for testing
    */
   async getMockResponse(request, startTime, subagentId) {
-    await new Promise((resolve) => setTimeout(resolve, Math.random() * 20 + 10));
+    await new Promise(
+      (resolve) => setTimeout(resolve, Math.random() * 20 + 10)
+    );
     const mockResponses = {
       planning: {
         tasks: [
@@ -357,10 +479,7 @@ function greetUser(name: string): string {
   }
   return \`Hello, \${name}!\`;
 }`,
-        changes_made: [
-          "Added JSDoc documentation",
-          "Improved error message"
-        ]
+        changes_made: ["Added JSDoc documentation", "Improved error message"]
       },
       context: {
         relevant_files: ["src/greet.ts", "test/greet.test.ts"],
@@ -415,7 +534,9 @@ function greetUser(name: string): string {
    */
   async mockTaskToolExecution(request) {
     const startTime = Date.now();
-    await new Promise((resolve) => setTimeout(resolve, 1e3 + Math.random() * 2e3));
+    await new Promise(
+      (resolve) => setTimeout(resolve, 1e3 + Math.random() * 2e3)
+    );
     const mockResponses = {
       planning: {
         tasks: [