@stackmemoryai/stackmemory 1.0.1 → 1.2.1

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
+};