@stackmemoryai/stackmemory 1.0.1 → 1.2.0

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

@@ -32,12 +32,19 @@ class GraphitiClient {
         const res = await fetch(`${this.endpoint}${path}`, {
           ...options,
           signal: controller.signal,
-          headers: { "Content-Type": "application/json", ...options.headers || {} }
+          headers: {
+            "Content-Type": "application/json",
+            ...options.headers || {}
+          }
         });
         clearTimeout(timeoutId);
         if (!res.ok) {
           const msg = await res.text().catch(() => res.statusText);
-          throw new GraphitiClientError(`Request failed: ${msg}`, "HTTP_ERROR", res.status);
+          throw new GraphitiClientError(
+            `Request failed: ${msg}`,
+            "HTTP_ERROR",
+            res.status
+          );
         }
         return await res.json();
       } catch (err) {
@@ -53,7 +60,10 @@ class GraphitiClient {
       }
     }
     clearTimeout(timeoutId);
-    throw new GraphitiClientError(lastError?.message || "Network error", "NETWORK_ERROR");
+    throw new GraphitiClientError(
+      lastError?.message || "Network error",
+      "NETWORK_ERROR"
+    );
   }
   // Episodes
   async upsertEpisode(episode) {
@@ -91,7 +101,9 @@ class GraphitiClient {
   // Health/status
   async getStatus() {
     try {
-      return await this.request(`/status?namespace=${encodeURIComponent(this.namespace)}`);
+      return await this.request(
+        `/status?namespace=${encodeURIComponent(this.namespace)}`
+      );
     } catch {
       return { connected: false };
     }

package/dist/src/integrations/mcp/handlers/index.js

@@ -15,6 +15,9 @@ import {
 import {
   DiscoveryHandlers
 } from "./discovery-handlers.js";
+import {
+  ProviderHandlers
+} from "./provider-handlers.js";
 import {
   ContextHandlers as ContextHandlers2
 } from "./context-handlers.js";
@@ -23,11 +26,13 @@ import {
   LinearHandlers as LinearHandlers2
 } from "./linear-handlers.js";
 import { TraceHandlers as TraceHandlers2 } from "./trace-handlers.js";
+import { ProviderHandlers as ProviderHandlers2 } from "./provider-handlers.js";
 class MCPHandlerFactory {
   contextHandlers;
   taskHandlers;
   linearHandlers;
   traceHandlers;
+  providerHandlers;
   constructor(deps) {
     this.contextHandlers = new ContextHandlers2({
       frameManager: deps.frameManager
@@ -45,6 +50,7 @@ class MCPHandlerFactory {
       traceDetector: deps.traceDetector,
       browserMCP: deps.browserMCP
     });
+    this.providerHandlers = new ProviderHandlers2();
   }
   /**
    * Get handler for a specific tool
@@ -111,6 +117,19 @@ class MCPHandlerFactory {
         return this.traceHandlers.handleStopBrowserDebug.bind(
           this.traceHandlers
         );
+      // Provider handlers
+      case "delegate_to_model":
+        return this.providerHandlers.handleDelegateToModel.bind(
+          this.providerHandlers
+        );
+      case "batch_submit":
+        return this.providerHandlers.handleBatchSubmit.bind(
+          this.providerHandlers
+        );
+      case "batch_check":
+        return this.providerHandlers.handleBatchCheck.bind(
+          this.providerHandlers
+        );
       default:
         throw new Error(`Unknown tool: ${toolName}`);
     }
@@ -144,7 +163,11 @@ class MCPHandlerFactory {
       "start_browser_debug",
       "take_screenshot",
       "execute_script",
-      "stop_browser_debug"
+      "stop_browser_debug",
+      // Provider tools (conditionally active)
+      "delegate_to_model",
+      "batch_submit",
+      "batch_check"
     ];
   }
   /**
@@ -159,6 +182,7 @@ export {
   DiscoveryHandlers,
   LinearHandlers,
   MCPHandlerFactory,
+  ProviderHandlers,
   TaskHandlers,
   TraceHandlers
 };

package/dist/src/integrations/mcp/handlers/provider-handlers.js

@@ -0,0 +1,227 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { logger } from "../../../core/monitoring/logger.js";
+import { isFeatureEnabled } from "../../../core/config/feature-flags.js";
+import {
+  createProvider
+} from "../../../core/extensions/provider-adapter.js";
+import {
+  getOptimalProvider
+} from "../../../core/models/model-router.js";
+import { scoreComplexity } from "../../../core/models/complexity-scorer.js";
+import {
+  AnthropicBatchClient
+} from "../../anthropic/batch-client.js";
+function errorResponse(err) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(err, null, 2) }]
+  };
+}
+function classifyApiError(error, provider) {
+  const msg = error.message || String(error);
+  const status = error.status || (msg.match(/(\d{3})/)?.[1] ? parseInt(msg.match(/(\d{3})/)[1]) : void 0);
+  if (status === 429) {
+    return {
+      errorType: "rate_limit",
+      message: msg,
+      recommendation: `Rate limited by ${provider}. Retry after a delay or switch to a different provider.`,
+      provider
+    };
+  }
+  if (status && status >= 500) {
+    return {
+      errorType: "server_error",
+      message: msg,
+      recommendation: `${provider} returned a server error. Try a different provider or retry later.`,
+      provider
+    };
+  }
+  return {
+    errorType: "api_error",
+    message: msg,
+    recommendation: `API call to ${provider} failed. Check the model name, API key, and base URL.`,
+    provider
+  };
+}
+class ProviderHandlers {
+  batchClient;
+  constructor(_deps) {
+  }
+  getBatchClient() {
+    if (!this.batchClient) {
+      this.batchClient = new AnthropicBatchClient();
+    }
+    return this.batchClient;
+  }
+  /**
+   * delegate_to_model — route a prompt to a specific provider+model
+   */
+  async handleDelegateToModel(args) {
+    if (!isFeatureEnabled("multiProvider")) {
+      return errorResponse({
+        errorType: "feature_disabled",
+        message: "Multi-provider routing is disabled.",
+        recommendation: "Set STACKMEMORY_MULTI_PROVIDER=true to enable multi-provider routing."
+      });
+    }
+    const taskType = args.taskType || "default";
+    const preference = args.provider;
+    const complexity = scoreComplexity(args.prompt);
+    const optimal = getOptimalProvider(taskType, preference, {
+      task: args.prompt
+    });
+    logger.info("delegate_to_model routing", {
+      taskType,
+      complexity: complexity.tier,
+      score: complexity.score,
+      provider: optimal.provider
+    });
+    const providerModel = args.model || optimal.model;
+    const apiKey = process.env[optimal.apiKeyEnv] || "";
+    if (!apiKey) {
+      return errorResponse({
+        errorType: "missing_api_key",
+        message: `No API key found for ${optimal.provider} (env: ${optimal.apiKeyEnv})`,
+        recommendation: `Set the ${optimal.apiKeyEnv} environment variable or choose a different provider.`,
+        provider: optimal.provider
+      });
+    }
+    try {
+      const adapter = createProvider(optimal.provider, {
+        apiKey,
+        baseUrl: optimal.baseUrl
+      });
+      const messages = [{ role: "user", content: args.prompt }];
+      const result = await adapter.complete(messages, {
+        model: providerModel,
+        maxTokens: args.maxTokens || 4096,
+        temperature: args.temperature,
+        system: args.system
+      });
+      const text = result.content.filter((c) => c.type === "text").map((c) => c.text).join("");
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                provider: optimal.provider,
+                model: providerModel,
+                response: text,
+                usage: result.usage
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    } catch (error) {
+      logger.error("delegate_to_model failed", { error: error.message });
+      return errorResponse(classifyApiError(error, optimal.provider));
+    }
+  }
+  /**
+   * batch_submit — submit prompts to Anthropic Batch API
+   */
+  async handleBatchSubmit(args) {
+    if (!isFeatureEnabled("multiProvider")) {
+      return errorResponse({
+        errorType: "feature_disabled",
+        message: "Multi-provider routing is disabled.",
+        recommendation: "Set STACKMEMORY_MULTI_PROVIDER=true to enable multi-provider routing."
+      });
+    }
+    try {
+      const batchClient = this.getBatchClient();
+      const requests = args.prompts.map((p) => ({
+        custom_id: p.id,
+        params: {
+          model: p.model || "claude-sonnet-4-5-20250929",
+          max_tokens: p.maxTokens || 4096,
+          messages: [{ role: "user", content: p.prompt }],
+          system: p.system
+        }
+      }));
+      const batchId = await batchClient.submit(requests, args.description);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                batchId,
+                status: "submitted",
+                requestCount: requests.length
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    } catch (error) {
+      return errorResponse({
+        errorType: "batch_error",
+        message: error.message,
+        recommendation: "Check ANTHROPIC_API_KEY and batch request format."
+      });
+    }
+  }
+  /**
+   * batch_check — poll status / retrieve results
+   */
+  async handleBatchCheck(args) {
+    if (!isFeatureEnabled("multiProvider")) {
+      return errorResponse({
+        errorType: "feature_disabled",
+        message: "Multi-provider routing is disabled.",
+        recommendation: "Set STACKMEMORY_MULTI_PROVIDER=true to enable multi-provider routing."
+      });
+    }
+    try {
+      const batchClient = this.getBatchClient();
+      const job = await batchClient.poll(args.batchId);
+      if (args.retrieve && job.processing_status === "ended") {
+        const results = await batchClient.retrieve(args.batchId);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({ job, results }, null, 2)
+            }
+          ]
+        };
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                batchId: args.batchId,
+                status: job.processing_status,
+                counts: job.request_counts,
+                createdAt: job.created_at,
+                endedAt: job.ended_at
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    } catch (error) {
+      return errorResponse({
+        errorType: "batch_error",
+        message: error.message,
+        recommendation: "Check the batchId is valid and ANTHROPIC_API_KEY is set."
+      });
+    }
+  }
+}
+export {
+  ProviderHandlers
+};

package/dist/src/integrations/mcp/server.js

@@ -30,6 +30,7 @@ import { TraceDetector } from "../../core/trace/trace-detector.js";
 import { LLMContextRetrieval } from "../../core/retrieval/index.js";
 import { DiscoveryHandlers } from "./handlers/discovery-handlers.js";
 import { DiffMemHandlers } from "./handlers/diffmem-handlers.js";
+import { fuzzyEdit } from "../../utils/fuzzy-edit.js";
 import { v4 as uuidv4 } from "uuid";
 import {
   DEFAULT_PLANNER_MODEL,
@@ -62,6 +63,7 @@ class LocalStackMemoryMCP {
   contextRetrieval;
   discoveryHandlers;
   diffMemHandlers;
+  providerHandlers = null;
   pendingPlans = /* @__PURE__ */ new Map();
   constructor() {
     this.projectRoot = this.findProjectRoot();
@@ -91,6 +93,18 @@ class LocalStackMemoryMCP {
         influence_score REAL,
         timestamp INTEGER DEFAULT (unixepoch())
       );
+
+      CREATE TABLE IF NOT EXISTS edit_telemetry (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        timestamp INTEGER NOT NULL DEFAULT (unixepoch()),
+        session_id TEXT,
+        tool_name TEXT NOT NULL,
+        file_path TEXT,
+        success INTEGER NOT NULL DEFAULT 1,
+        error_type TEXT,
+        error_message TEXT
+      );
+      CREATE INDEX IF NOT EXISTS idx_edit_telemetry_ts ON edit_telemetry(timestamp);
     `);
     this.frameManager = new FrameManager(this.db, this.projectId);
     this.initLinearIfEnabled();
@@ -122,6 +136,7 @@ class LocalStackMemoryMCP {
       projectRoot: this.projectRoot
     });
     this.diffMemHandlers = new DiffMemHandlers();
+    this.initProviderHandlers();
     this.setupHandlers();
     this.loadInitialContext();
     this.loadPendingPlans();
@@ -243,6 +258,16 @@ ${summary}...`, 0.8);
       this.contexts.set(ctx.id, ctx);
     });
   }
+  async initProviderHandlers() {
+    if (!isFeatureEnabled("multiProvider")) return;
+    try {
+      const { ProviderHandlers } = await import("./handlers/provider-handlers.js");
+      this.providerHandlers = new ProviderHandlers();
+      logger.info("Provider handlers initialized (multiProvider enabled)");
+    } catch (error) {
+      logger.warn("Failed to initialize provider handlers", { error });
+    }
+  }
   setupHandlers() {
     this.server.setRequestHandler(
       z.object({
@@ -1047,7 +1072,108 @@ ${summary}...`, 0.8);
                 type: "object",
                 properties: {}
               }
-            }
+            },
+            // Provider tools (only active when STACKMEMORY_MULTI_PROVIDER=true)
+            ...isFeatureEnabled("multiProvider") ? [
+              {
+                name: "delegate_to_model",
+                description: "Route a prompt to a specific provider/model. Uses smart cost-based routing by default.",
+                inputSchema: {
+                  type: "object",
+                  properties: {
+                    prompt: {
+                      type: "string",
+                      description: "The prompt to send"
+                    },
+                    provider: {
+                      type: "string",
+                      enum: [
+                        "anthropic",
+                        "cerebras",
+                        "deepinfra",
+                        "openai",
+                        "openrouter"
+                      ],
+                      description: "Override provider (auto-routes if omitted)"
+                    },
+                    model: {
+                      type: "string",
+                      description: "Override model name"
+                    },
+                    taskType: {
+                      type: "string",
+                      enum: [
+                        "linting",
+                        "context",
+                        "code",
+                        "testing",
+                        "review",
+                        "plan"
+                      ],
+                      description: "Task type for auto-routing"
+                    },
+                    maxTokens: {
+                      type: "number",
+                      description: "Max tokens"
+                    },
+                    temperature: { type: "number" },
+                    system: {
+                      type: "string",
+                      description: "System prompt"
+                    }
+                  },
+                  required: ["prompt"]
+                }
+              },
+              {
+                name: "batch_submit",
+                description: "Submit prompts to Anthropic Batch API (50% discount, async)",
+                inputSchema: {
+                  type: "object",
+                  properties: {
+                    prompts: {
+                      type: "array",
+                      items: {
+                        type: "object",
+                        properties: {
+                          id: { type: "string" },
+                          prompt: { type: "string" },
+                          model: { type: "string" },
+                          maxTokens: { type: "number" },
+                          system: { type: "string" }
+                        },
+                        required: ["id", "prompt"]
+                      },
+                      description: "Array of prompts to batch"
+                    },
+                    description: {
+                      type: "string",
+                      description: "Batch job description"
+                    }
+                  },
+                  required: ["prompts"]
+                }
+              },
+              {
+                name: "batch_check",
+                description: "Check status or retrieve results for a batch job",
+                inputSchema: {
+                  type: "object",
+                  properties: {
+                    batchId: {
+                      type: "string",
+                      description: "Batch job ID"
+                    },
+                    retrieve: {
+                      type: "boolean",
+                      description: "Retrieve results if complete",
+                      default: false
+                    }
+                  },
+                  required: ["batchId"]
+                }
+              }
+            ] : []
           ]
         };
       }
@@ -1195,6 +1321,58 @@ ${summary}...`, 0.8);
             case "diffmem_status":
               result = await this.diffMemHandlers.handleStatus();
               break;
+            case "sm_edit":
+              result = await this.handleSmEdit(args);
+              break;
+            // Provider tools
+            case "delegate_to_model":
+              if (!this.providerHandlers) {
+                result = {
+                  content: [
+                    {
+                      type: "text",
+                      text: "Multi-provider routing is disabled."
+                    }
+                  ]
+                };
+              } else {
+                result = await this.providerHandlers.handleDelegateToModel(
+                  args
+                );
+              }
+              break;
+            case "batch_submit":
+              if (!this.providerHandlers) {
+                result = {
+                  content: [
+                    {
+                      type: "text",
+                      text: "Multi-provider routing is disabled."
+                    }
+                  ]
+                };
+              } else {
+                result = await this.providerHandlers.handleBatchSubmit(
+                  args
+                );
+              }
+              break;
+            case "batch_check":
+              if (!this.providerHandlers) {
+                result = {
+                  content: [
+                    {
+                      type: "text",
+                      text: "Multi-provider routing is disabled."
+                    }
+                  ]
+                };
+              } else {
+                result = await this.providerHandlers.handleBatchCheck(
+                  args
+                );
+              }
+              break;
             default:
               throw new Error(`Unknown tool: ${name}`);
           }
@@ -2639,6 +2817,34 @@ ${typeBreakdown}`
       };
     }
   }
+  async handleSmEdit(args) {
+    const {
+      file_path: filePath,
+      old_string: oldString,
+      new_string: newString,
+      threshold = 0.85
+    } = args;
+    if (!filePath || !oldString || newString === void 0) {
+      throw new Error("file_path, old_string, and new_string are required");
+    }
+    const { readFileSync: readFileSync2, writeFileSync: writeFileSync2 } = await import("fs");
+    const content = readFileSync2(filePath, "utf-8");
+    const editResult = fuzzyEdit(content, oldString, newString, threshold);
+    if (!editResult) {
+      return {
+        success: false,
+        error: "No match found above threshold",
+        threshold
+      };
+    }
+    writeFileSync2(filePath, editResult.content, "utf-8");
+    return {
+      success: true,
+      method: editResult.match.method,
+      confidence: editResult.match.confidence,
+      matchedText: editResult.match.matchedText.length > 200 ? editResult.match.matchedText.slice(0, 200) + "..." : editResult.match.matchedText
+    };
+  }
   async start() {
     const transport = new StdioServerTransport();
     await this.server.connect(transport);

package/dist/src/integrations/mcp/tool-definitions.js

@@ -12,7 +12,8 @@ class MCPToolDefinitions {
       ...this.getTaskTools(),
       ...this.getLinearTools(),
       ...this.getTraceTools(),
-      ...this.getDiscoveryTools()
+      ...this.getDiscoveryTools(),
+      ...this.getEditTools()
     ];
   }
   /**
@@ -670,6 +671,40 @@ class MCPToolDefinitions {
       }
     ];
   }
+  /**
+   * Edit tools (fuzzy edit fallback)
+   */
+  getEditTools() {
+    return [
+      {
+        name: "sm_edit",
+        description: "Fuzzy file edit \u2014 fallback when Claude Code's Edit tool fails on whitespace or indentation mismatches. Uses four-tier matching: exact, whitespace-normalized, indentation-insensitive, and line-level fuzzy (Levenshtein).",
+        inputSchema: {
+          type: "object",
+          properties: {
+            file_path: {
+              type: "string",
+              description: "Absolute path to the file to edit"
+            },
+            old_string: {
+              type: "string",
+              description: "The text to find and replace"
+            },
+            new_string: {
+              type: "string",
+              description: "The replacement text"
+            },
+            threshold: {
+              type: "number",
+              default: 0.85,
+              description: "Minimum similarity threshold for fuzzy matching (0-1). Default 0.85."
+            }
+          },
+          required: ["file_path", "old_string", "new_string"]
+        }
+      }
+    ];
+  }
   /**
    * Get tool definition by name
    */
@@ -691,6 +726,8 @@ class MCPToolDefinitions {
         return this.getTraceTools();
       case "discovery":
         return this.getDiscoveryTools();
+      case "edit":
+        return this.getEditTools();
       default:
         return [];
     }