@stackmemoryai/stackmemory 1.0.1 → 1.2.0

package/dist/src/cli/commands/audit.js

@@ -0,0 +1,134 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { Command } from "commander";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+let countTokens;
+try {
+  const tokenizer = await import("@anthropic-ai/tokenizer");
+  countTokens = tokenizer.countTokens;
+} catch {
+  countTokens = (text) => Math.ceil(text.length / 3.5);
+}
+function readFileSafe(filePath) {
+  try {
+    if (existsSync(filePath)) {
+      return readFileSync(filePath, "utf-8");
+    }
+  } catch {
+  }
+  return null;
+}
+function createAuditCommand() {
+  const audit = new Command("audit").description(
+    "Measure context overhead (tokens injected before first message)"
+  ).option("--json", "Output as JSON", false).action(async (options) => {
+    const projectRoot = process.cwd();
+    const home = homedir();
+    const entries = [];
+    const globalClaudeMd = readFileSafe(join(home, ".claude", "CLAUDE.md"));
+    if (globalClaudeMd) {
+      entries.push({
+        source: "~/.claude/CLAUDE.md",
+        tokens: countTokens(globalClaudeMd),
+        percent: 0
+      });
+    }
+    const projectClaudeMd = readFileSafe(join(projectRoot, "CLAUDE.md"));
+    if (projectClaudeMd) {
+      entries.push({
+        source: "./CLAUDE.md",
+        tokens: countTokens(projectClaudeMd),
+        percent: 0
+      });
+    }
+    const projectSlug = projectRoot.replace(/\//g, "-");
+    const memoryPath = join(
+      home,
+      ".claude",
+      "projects",
+      projectSlug,
+      "memory",
+      "MEMORY.md"
+    );
+    const memoryMd = readFileSafe(memoryPath);
+    if (memoryMd) {
+      entries.push({
+        source: "auto-memory/MEMORY.md",
+        tokens: countTokens(memoryMd),
+        percent: 0
+      });
+    }
+    const handoffPath = join(projectRoot, ".stackmemory", "handoff.md");
+    const handoffMd = readFileSafe(handoffPath);
+    if (handoffMd) {
+      entries.push({
+        source: ".stackmemory/handoff.md",
+        tokens: countTokens(handoffMd),
+        percent: 0
+      });
+    }
+    try {
+      const { MCPToolDefinitions } = await import("../../integrations/mcp/tool-definitions.js");
+      const defs = new MCPToolDefinitions();
+      const allTools = defs.getAllToolDefinitions();
+      const schemasJson = JSON.stringify(allTools);
+      entries.push({
+        source: "MCP tool schemas",
+        tokens: countTokens(schemasJson),
+        percent: 0
+      });
+    } catch {
+    }
+    try {
+      const dbPath = join(projectRoot, ".stackmemory", "context.db");
+      if (existsSync(dbPath)) {
+        const { default: Database } = await import("better-sqlite3");
+        const { FrameManager } = await import("../../core/context/index.js");
+        const db = new Database(dbPath);
+        const fm = new FrameManager(db, "cli-project");
+        const hotStack = fm.getHotStackContext();
+        if (hotStack) {
+          entries.push({
+            source: "Active frames (hot stack)",
+            tokens: countTokens(hotStack),
+            percent: 0
+          });
+        }
+        db.close();
+      }
+    } catch {
+    }
+    const totalTokens = entries.reduce((sum, e) => sum + e.tokens, 0);
+    for (const entry of entries) {
+      entry.percent = totalTokens > 0 ? Math.round(entry.tokens / totalTokens * 1e3) / 10 : 0;
+    }
+    if (options.json) {
+      console.log(JSON.stringify({ entries, totalTokens }, null, 2));
+      return;
+    }
+    console.log("\nContext Overhead Audit");
+    console.log("\u2500".repeat(60));
+    console.log(
+      `${"Source".padEnd(32)} ${"Tokens".padStart(8)} ${"%".padStart(7)}`
+    );
+    console.log("\u2500".repeat(60));
+    for (const entry of entries) {
+      console.log(
+        `${entry.source.padEnd(32)} ${String(entry.tokens).padStart(8)} ${(entry.percent + "%").padStart(7)}`
+      );
+    }
+    console.log("\u2500".repeat(60));
+    console.log(
+      `${"TOTAL".padEnd(32)} ${String(totalTokens).padStart(8)} ${"100%".padStart(7)}`
+    );
+    console.log("");
+  });
+  return audit;
+}
+export {
+  createAuditCommand
+};

package/dist/src/cli/commands/bench.js

@@ -0,0 +1,252 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { Command } from "commander";
+import { existsSync, readFileSync, readdirSync } from "fs";
+import { join } from "path";
+import {
+  SWE_BENCH_BASELINES,
+  HARNESS_TARGETS,
+  summarizeRuns
+} from "../../orchestrators/multimodal/baselines.js";
+import {
+  feedbackLoops
+} from "../../core/monitoring/feedback-loops.js";
+function loadRunMetrics(projectRoot) {
+  const metricsFile = join(
+    projectRoot,
+    ".stackmemory",
+    "build",
+    "harness-metrics.jsonl"
+  );
+  if (!existsSync(metricsFile)) return [];
+  const lines = readFileSync(metricsFile, "utf-8").split("\n").filter((l) => l.trim());
+  const runs = [];
+  for (const line of lines) {
+    try {
+      runs.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return runs;
+}
+function loadSpikeAudits(projectRoot) {
+  const dir = join(projectRoot, ".stackmemory", "build");
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir).filter((f) => f.startsWith("spike-") && f.endsWith(".json")).sort().reverse().slice(0, 20).map((f) => {
+    try {
+      return {
+        file: f,
+        data: JSON.parse(readFileSync(join(dir, f), "utf-8"))
+      };
+    } catch {
+      return null;
+    }
+  }).filter(Boolean);
+}
+function createBenchCommand() {
+  const bench = new Command("bench").description(
+    "Harness benchmarks \u2014 compare local runs against SWE-bench baselines"
+  ).option("--json", "Output as JSON", false).option("-d, --days <n>", "Only include runs from last N days", "30").option("--baselines", "Show online benchmark baselines only", false).action(async (options) => {
+    const projectRoot = process.cwd();
+    if (options.baselines) {
+      if (options.json) {
+        console.log(
+          JSON.stringify(
+            { baselines: SWE_BENCH_BASELINES, targets: HARNESS_TARGETS },
+            null,
+            2
+          )
+        );
+        return;
+      }
+      console.log("\nOnline Benchmark Baselines (SWE-bench Verified)");
+      console.log("\u2500".repeat(60));
+      console.log(
+        `${"Agent".padEnd(20)} ${"Model".padEnd(20)} ${"Resolve".padStart(8)}`
+      );
+      console.log("\u2500".repeat(60));
+      for (const b of SWE_BENCH_BASELINES) {
+        console.log(
+          `${b.agent.padEnd(20)} ${b.model.padEnd(20)} ${(b.resolveRate * 100).toFixed(1).padStart(7)}%`
+        );
+      }
+      console.log("\u2500".repeat(60));
+      console.log("\nInternal Harness Targets");
+      console.log("\u2500".repeat(60));
+      console.log(
+        `  Plan latency P95:        ${HARNESS_TARGETS.planLatencyP95Ms}ms`
+      );
+      console.log(
+        `  Total latency P95:       ${HARNESS_TARGETS.totalLatencyP95Ms}ms`
+      );
+      console.log(
+        `  Single-iter latency P95: ${HARNESS_TARGETS.singleIterLatencyP95Ms}ms`
+      );
+      console.log(
+        `  First-pass approval:     ${(HARNESS_TARGETS.firstPassApprovalRate * 100).toFixed(0)}%`
+      );
+      console.log(
+        `  Edit success rate:       ${(HARNESS_TARGETS.editSuccessRate * 100).toFixed(0)}%`
+      );
+      console.log(
+        `  Fuzzy fallback rate:     <${(HARNESS_TARGETS.editFuzzyFallbackRate * 100).toFixed(0)}%`
+      );
+      console.log(
+        `  Context token budget:    ${HARNESS_TARGETS.contextTokenBudget}`
+      );
+      console.log("");
+      return;
+    }
+    const days = parseInt(options.days, 10) || 30;
+    const cutoff = Date.now() - days * 864e5;
+    const allRuns = loadRunMetrics(projectRoot);
+    const runs = allRuns.filter((r) => r.timestamp >= cutoff);
+    const audits = loadSpikeAudits(projectRoot);
+    if (options.json) {
+      const summary2 = summarizeRuns(runs);
+      console.log(
+        JSON.stringify(
+          {
+            summary: summary2,
+            baselines: SWE_BENCH_BASELINES,
+            targets: HARNESS_TARGETS,
+            runsInWindow: runs.length,
+            totalRuns: allRuns.length,
+            recentAudits: audits.length
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    console.log(`
+Harness Benchmark Report (last ${days} days)`);
+    console.log("\u2550".repeat(60));
+    if (runs.length === 0) {
+      console.log("\nNo harness runs recorded yet.");
+      console.log('Run: stackmemory build "your task" --execute');
+      console.log('Or:  stackmemory mm-spike -t "task" --execute\n');
+      console.log("Online Baselines (SWE-bench Verified):");
+      for (const b of SWE_BENCH_BASELINES.slice(0, 3)) {
+        console.log(
+          `  ${b.agent.padEnd(16)} ${(b.resolveRate * 100).toFixed(1)}%`
+        );
+      }
+      console.log("");
+      return;
+    }
+    const summary = summarizeRuns(runs);
+    console.log("\nHarness Metrics:");
+    console.log(`  Total runs:            ${summary.totalRuns}`);
+    console.log(
+      `  Approval rate:         ${(summary.approvalRate * 100).toFixed(1)}%`
+    );
+    console.log(
+      `  First-pass rate:       ${(summary.firstPassRate * 100).toFixed(1)}%`
+    );
+    console.log(
+      `  Avg iterations:        ${summary.avgIterations.toFixed(1)}`
+    );
+    console.log(
+      `  Plan latency (avg):    ${Math.round(summary.avgPlanLatencyMs)}ms`
+    );
+    console.log(
+      `  Plan latency (P95):    ${Math.round(summary.p95PlanLatencyMs)}ms`
+    );
+    console.log(
+      `  Total latency (avg):   ${Math.round(summary.avgTotalLatencyMs)}ms`
+    );
+    console.log(
+      `  Total latency (P95):   ${Math.round(summary.p95TotalLatencyMs)}ms`
+    );
+    console.log(
+      `  Edit success rate:     ${(summary.editSuccessRate * 100).toFixed(1)}%`
+    );
+    console.log(
+      `  Fuzzy fallback rate:   ${(summary.editFuzzyRate * 100).toFixed(1)}%`
+    );
+    console.log(
+      `  Context tokens (avg):  ${Math.round(summary.avgContextTokens)}`
+    );
+    console.log("\nTarget Comparison:");
+    const checks = summary.passesTargets;
+    for (const [key, passes] of Object.entries(checks)) {
+      const icon = passes ? "PASS" : "FAIL";
+      console.log(`  [${icon}] ${key}`);
+    }
+    console.log("\nOnline Baselines (SWE-bench Verified):");
+    for (const b of SWE_BENCH_BASELINES.slice(0, 4)) {
+      console.log(
+        `  ${b.agent.padEnd(16)} ${(b.resolveRate * 100).toFixed(1)}%`
+      );
+    }
+    if (audits.length > 0) {
+      console.log(`
+Recent Spike Audits (${audits.length}):`);
+      for (const a of audits.slice(0, 5)) {
+        const task = a.data?.input?.task || "(unknown)";
+        const approved = a.data?.iterations?.some(
+          (it) => it.critique?.approved
+        );
+        const icon = approved ? "OK" : "--";
+        console.log(`  [${icon}] ${task.slice(0, 50)}`);
+      }
+    }
+    console.log("");
+  });
+  bench.command("loops").description("Show feedback loop configuration, status, and recent events").option("--json", "Output as JSON", false).action((options) => {
+    const config = feedbackLoops.getConfig();
+    const stats = feedbackLoops.getStats();
+    const history = feedbackLoops.getHistory(void 0, 20);
+    if (options.json) {
+      console.log(JSON.stringify({ config, stats, history }, null, 2));
+      return;
+    }
+    console.log("\nFeedback Loops");
+    console.log("\u2550".repeat(60));
+    const loopDescriptions = {
+      contextPressure: "Context 70%+ \u2192 auto-digest old frames",
+      editRecovery: "Edit failure \u2192 sm_edit fuzzy fallback \u2192 telemetry",
+      retrievalQuality: "Empty results > 20% \u2192 switch search strategy",
+      traceErrorChain: "Same error 3x \u2192 surface anchor + memory",
+      harnessRegression: "Approval rate drops \u2192 regression alert",
+      sessionDrift: "Depth > 5 or stale frames \u2192 auto-checkpoint"
+    };
+    console.log("\nLoop Configuration:");
+    for (const [name, cfg] of Object.entries(config)) {
+      const icon = cfg.enabled ? " ON" : "OFF";
+      const desc = loopDescriptions[name] || name;
+      const cooldown = cfg.cooldownSec > 0 ? ` (cooldown ${cfg.cooldownSec}s)` : "";
+      console.log(`  [${icon}] ${name.padEnd(22)} ${desc}${cooldown}`);
+    }
+    if (Object.keys(stats).length > 0) {
+      console.log("\nLoop Stats (this session):");
+      for (const [name, s] of Object.entries(stats)) {
+        const ago = s.lastFired ? `${Math.round((Date.now() - s.lastFired) / 1e3)}s ago` : "never";
+        console.log(
+          `  ${name.padEnd(22)} ${s.fires} fires, ${s.successes} ok, ${s.errors} err (last: ${ago})`
+        );
+      }
+    }
+    if (history.length > 0) {
+      console.log(`
+Recent Events (${history.length}):`);
+      for (const e of history.slice(-10)) {
+        const time = new Date(e.timestamp).toISOString().slice(11, 19);
+        console.log(
+          `  ${time} [${e.loop}] ${e.trigger} \u2192 ${e.action} (${e.outcome})`
+        );
+      }
+    } else {
+      console.log("\nNo loop events fired yet this session.");
+    }
+    console.log("");
+  });
+  return bench;
+}
+export {
+  createBenchCommand
+};

package/dist/src/cli/commands/dashboard.js

@@ -9,6 +9,7 @@ import { SessionManager } from "../../core/session/session-manager.js";
 import Database from "better-sqlite3";
 import { join } from "path";
 import { existsSync } from "fs";
+import { getModelTokenLimit } from "../../core/models/model-router.js";
 const dashboardCommand = {
   command: "dashboard",
   describe: "Display monitoring dashboard in terminal",
@@ -201,7 +202,7 @@ async function estimateContextUsage(db) {
   ).get();
   const totalBytes = (result?.input_size || 0) + (result?.output_size || 0);
   const estimatedTokens = totalBytes / 4;
-  const maxTokens = 128e3;
+  const maxTokens = getModelTokenLimit(process.env.ANTHROPIC_MODEL);
   return Math.round(estimatedTokens / maxTokens * 100);
 }
 export {

package/dist/src/cli/commands/stats.js

@@ -0,0 +1,118 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { Command } from "commander";
+import { existsSync } from "fs";
+import { join } from "path";
+function createStatsCommand() {
+  const stats = new Command("stats").description("Show telemetry statistics").argument("[category]", "Category to show (edits)", "edits").option("-d, --days <n>", "Number of days to show trend", "7").option("--json", "Output as JSON", false).action(async (category, options) => {
+    if (category !== "edits") {
+      console.log(`Unknown stats category: ${category}`);
+      console.log("Available: edits");
+      return;
+    }
+    const projectRoot = process.cwd();
+    const dbPath = join(projectRoot, ".stackmemory", "context.db");
+    if (!existsSync(dbPath)) {
+      console.log('No data. Run "stackmemory init" first.');
+      return;
+    }
+    const { default: Database } = await import("better-sqlite3");
+    const db = new Database(dbPath);
+    const tableExists = db.prepare(
+      "SELECT name FROM sqlite_master WHERE type='table' AND name='edit_telemetry'"
+    ).get();
+    if (!tableExists) {
+      db.close();
+      console.log("No edit telemetry data yet.");
+      console.log("Edit telemetry is collected via the PostToolUse hook.");
+      return;
+    }
+    const days = parseInt(options.days, 10) || 7;
+    const cutoff = Math.floor(Date.now() / 1e3) - days * 86400;
+    const byTool = db.prepare(
+      `SELECT
+            tool_name,
+            COUNT(*) as total,
+            SUM(CASE WHEN success = 1 THEN 1 ELSE 0 END) as successes,
+            SUM(CASE WHEN success = 0 THEN 1 ELSE 0 END) as failures
+          FROM edit_telemetry
+          WHERE timestamp >= ?
+          GROUP BY tool_name
+          ORDER BY total DESC`
+    ).all(cutoff);
+    const topFails = db.prepare(
+      `SELECT file_path, COUNT(*) as fail_count
+          FROM edit_telemetry
+          WHERE success = 0 AND timestamp >= ? AND file_path IS NOT NULL
+          GROUP BY file_path
+          ORDER BY fail_count DESC
+          LIMIT 10`
+    ).all(cutoff);
+    const errorTypes = db.prepare(
+      `SELECT error_type, COUNT(*) as count
+          FROM edit_telemetry
+          WHERE success = 0 AND timestamp >= ? AND error_type IS NOT NULL
+          GROUP BY error_type
+          ORDER BY count DESC`
+    ).all(cutoff);
+    const trend = db.prepare(
+      `SELECT
+            date(timestamp, 'unixepoch') as day,
+            COUNT(*) as total,
+            SUM(CASE WHEN success = 0 THEN 1 ELSE 0 END) as failures
+          FROM edit_telemetry
+          WHERE timestamp >= ?
+          GROUP BY day
+          ORDER BY day DESC`
+    ).all(cutoff);
+    db.close();
+    if (options.json) {
+      console.log(
+        JSON.stringify({ byTool, topFails, errorTypes, trend }, null, 2)
+      );
+      return;
+    }
+    console.log(`
+Edit Telemetry (last ${days} days)`);
+    console.log("\u2500".repeat(50));
+    if (byTool.length === 0) {
+      console.log("No edit telemetry data in this period.");
+      return;
+    }
+    console.log("\nSuccess Rate by Tool:");
+    for (const row of byTool) {
+      const rate = row.total > 0 ? Math.round(row.successes / row.total * 100) : 0;
+      console.log(
+        `  ${row.tool_name.padEnd(20)} ${rate}% (${row.successes}/${row.total})`
+      );
+    }
+    if (topFails.length > 0) {
+      console.log("\nTop Failure Files:");
+      for (const row of topFails) {
+        console.log(`  ${row.file_path} (${row.fail_count}x)`);
+      }
+    }
+    if (errorTypes.length > 0) {
+      console.log("\nError Types:");
+      for (const row of errorTypes) {
+        console.log(`  ${row.error_type.padEnd(30)} ${row.count}x`);
+      }
+    }
+    if (trend.length > 0) {
+      console.log("\nDaily Trend:");
+      for (const row of trend) {
+        const failRate = row.total > 0 ? Math.round(row.failures / row.total * 100) : 0;
+        console.log(
+          `  ${row.day}  ${row.total} edits, ${row.failures} failures (${failRate}%)`
+        );
+      }
+    }
+    console.log("");
+  });
+  return stats;
+}
+export {
+  createStatsCommand
+};

package/dist/src/cli/index.js

@@ -51,6 +51,9 @@ import { createDiscoveryCommands } from "./commands/discovery.js";
 import { createModelCommand } from "./commands/model.js";
 import { registerSetupCommands } from "./commands/setup.js";
 import { createPingCommand } from "./commands/ping.js";
+import { createAuditCommand } from "./commands/audit.js";
+import { createStatsCommand } from "./commands/stats.js";
+import { createBenchCommand } from "./commands/bench.js";
 import chalk from "chalk";
 import * as fs from "fs";
 import * as path from "path";
@@ -551,6 +554,9 @@ program.addCommand(createPingCommand());
 program.addCommand(createRetrievalCommands());
 program.addCommand(createDiscoveryCommands());
 program.addCommand(createModelCommand());
+program.addCommand(createAuditCommand());
+program.addCommand(createStatsCommand());
+program.addCommand(createBenchCommand());
 registerSetupCommands(program);
 program.command("mm-spike").description(
   "Run multi-agent planning/implementation spike (planner/implementer/critic)"

package/dist/src/core/config/feature-flags.js

@@ -19,6 +19,8 @@ function isFeatureEnabled(feature) {
       return process.env["STACKMEMORY_SKILLS"] === "true" || process.env["STACKMEMORY_SKILLS"] === "1";
     case "ralph":
       return process.env["STACKMEMORY_RALPH"] !== "false";
+    case "multiProvider":
+      return process.env["STACKMEMORY_MULTI_PROVIDER"] === "true" || process.env["STACKMEMORY_MULTI_PROVIDER"] === "1";
     default:
       return false;
   }
@@ -30,7 +32,8 @@ function getFeatureFlags() {
     chromadb: isFeatureEnabled("chromadb"),
     aiSummaries: isFeatureEnabled("aiSummaries"),
     skills: isFeatureEnabled("skills"),
-    ralph: isFeatureEnabled("ralph")
+    ralph: isFeatureEnabled("ralph"),
+    multiProvider: isFeatureEnabled("multiProvider")
   };
 }
 function logFeatureStatus() {
@@ -53,6 +56,9 @@ function logFeatureStatus() {
     console.log(
       `  Ralph: ${flags.ralph ? "enabled" : "disabled (set STACKMEMORY_RALPH=true)"}`
     );
+    console.log(
+      `  MultiProvider: ${flags.multiProvider ? "enabled" : "disabled (set STACKMEMORY_MULTI_PROVIDER=true)"}`
+    );
   }
 }
 export {

package/dist/src/core/context/enhanced-rehydration.js

@@ -5,22 +5,41 @@ const __dirname = __pathDirname(__filename);
 import * as fs from "fs/promises";
 import * as path from "path";
 import { logger } from "../monitoring/logger.js";
+import {
+  getModelTokenLimit
+} from "../models/model-router.js";
 class CompactionHandler {
   frameManager;
   metrics;
   tokenAccumulator = 0;
   preservedAnchors = /* @__PURE__ */ new Map();
-  constructor(frameManager) {
+  modelTokenLimit;
+  /**
+   * @param frameManager - Frame manager instance
+   * @param modelOrLimit - Model name string (looked up in MODEL_TOKEN_LIMITS)
+   *                       or explicit numeric token limit.
+   *                       Defaults to DEFAULT_MODEL_TOKEN_LIMIT (200K).
+   *
+   * Thresholds are derived from the model limit:
+   *   warning  = 90% of limit
+   *   critical = 95% of limit (auto-compact trigger)
+   */
+  constructor(frameManager, modelOrLimit) {
     this.frameManager = frameManager;
+    this.modelTokenLimit = typeof modelOrLimit === "number" ? modelOrLimit : getModelTokenLimit(modelOrLimit ?? void 0);
     this.metrics = {
       estimatedTokens: 0,
-      warningThreshold: 15e4,
-      // 150K tokens
-      criticalThreshold: 17e4,
-      // 170K tokens
+      warningThreshold: Math.floor(this.modelTokenLimit * 0.9),
+      criticalThreshold: Math.floor(this.modelTokenLimit * 0.95),
       anchorsPreserved: 0
     };
   }
+  /**
+   * Get the resolved model token limit
+   */
+  getModelTokenLimit() {
+    return this.modelTokenLimit;
+  }
   /**
    * Track token usage from a message
    */

package/dist/src/core/extensions/cerebras-adapter.js

@@ -0,0 +1,28 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import {
+  GPTAdapter
+} from "./provider-adapter.js";
+class CerebrasAdapter extends GPTAdapter {
+  id = "cerebras";
+  name = "Cerebras";
+  version = "1.0.0";
+  extensions = {};
+  constructor(config) {
+    super({
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl || "https://api.cerebras.ai/v1"
+    });
+  }
+  supportsExtension() {
+    return false;
+  }
+  async listModels() {
+    return ["llama-4-scout-17b-16e-instruct", "llama3.1-8b", "llama3.1-70b"];
+  }
+}
+export {
+  CerebrasAdapter
+};

package/dist/src/core/extensions/deepinfra-adapter.js

@@ -0,0 +1,32 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import {
+  GPTAdapter
+} from "./provider-adapter.js";
+class DeepInfraAdapter extends GPTAdapter {
+  id = "deepinfra";
+  name = "DeepInfra";
+  version = "1.0.0";
+  extensions = {};
+  constructor(config) {
+    super({
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl || "https://api.deepinfra.com/v1/openai"
+    });
+  }
+  supportsExtension() {
+    return false;
+  }
+  async listModels() {
+    return [
+      "THUDM/glm-4-9b-chat",
+      "meta-llama/Meta-Llama-3.1-8B-Instruct",
+      "meta-llama/Meta-Llama-3.1-70B-Instruct"
+    ];
+  }
+}
+export {
+  DeepInfraAdapter
+};