@polderlabs/bizar 10.1.0 → 10.3.0

package/packages/sdk/dist/mcp/server.js

@@ -42,11 +42,13 @@ import { checkDangerous } from "../dangerous-patterns.js";
 import { ModelRouter } from "../router/model-router.js";
 import { QLearningRouter } from "../router/q-learning-router.js";
 import { runDistillation } from "../router/memory-distillation.js";
-import { decideAgentWith } from "../router/index.js";
+import { decideAgentWith, loadModelRegistry, resolveAgentModel, resolveTierModel, } from "../router/index.js";
 import { bizarAgentRegistry } from "../agent-registry.js";
 import { initSwarm as initSwarmOnRegistry, DEFAULT_TOPOLOGY, DEFAULT_MAX_AGENTS, } from "../swarm-topology.js";
 import { getSharedConsensus } from "../consensus/index.js";
 import { createFederation, } from "../federation/index.js";
+import { startHeartbeat, stopHeartbeat, failHeartbeat, } from "../agent/heartbeat.js";
+import { addCronTask, listCronTasks, removeCronTask, } from "../agent/cron.js";
 /**
  * Build a single MCP tool definition with a zod-less validator. This
  * avoids taking a hard dep on zod at SDK-level; the dashboard or
@@ -491,6 +493,47 @@ const hooksRouteTool = defineTool("hooks_route", "Self-Learning router (F-033):
     }
 }, { readOnlyHint: true });
 // ---------------------------------------------------------------------------
+// Agent → model resolution tool (v10.1.0)
+//
+// Reads `.claude/model-router.json` (the Bizar model registry) and
+// returns the concrete modelId + endpoint URL for an agent name. This
+// is the bridge between the orchestrator's tier decision and the
+// downstream HTTP call — the orchestrator says "flash / mid / expensive",
+// this tool says "use this specific model at this URL".
+//
+// Pair with `hooks_route`: pass `agent=...` and you get the resolved
+// model in one call. Use `list=true` to dump the entire registry for
+// the dashboard / debugging.
+// ---------------------------------------------------------------------------
+const routeAgentTool = defineTool("route_agent", "Resolve an agent name (e.g. 'odin', 'thor', 'tyr') to its concrete modelId + endpoint URL by reading .claude/model-router.json. Pass {list: true} to dump the full registry. Returns JSON: {agent, modelId, tier, endpoint, rationale, fallback?, allAgents?}.", { agent: "string", list: "boolean" }, async ({ agent, list }) => {
+    try {
+        const reg = loadModelRegistry();
+        if (list === true) {
+            return ok(JSON.stringify({
+                endpoint: reg.endpoint,
+                agents: Array.from(reg.agents.values()),
+                tiers: Array.from(reg.tiers.values()),
+                fallbackChain: reg.fallbackChain,
+                gptOnlyFor: reg.gptOnlyFor,
+                gptNeverFor: reg.gptNeverFor,
+            }, null, 2));
+        }
+        const name = typeof agent === "string" && agent.trim().length > 0
+            ? agent.trim()
+            : "odin";
+        const resolved = resolveAgentModel(name, reg);
+        const tierResolved = resolveTierModel(resolved.tier, reg);
+        return ok(JSON.stringify({
+            ...resolved,
+            fallback: tierResolved.fallback,
+            allAgents: Array.from(reg.agents.keys()),
+        }, null, 2));
+    }
+    catch (e) {
+        return err(String(e));
+    }
+}, { readOnlyHint: true });
+// ---------------------------------------------------------------------------
 // Consensus tool (F-039) — thin PBFT-style 3-of-5 majority for
 // review/decision steps. Wraps the shared `getSharedConsensus()`
 // orchestrator; the MCP surface is intentionally minimal (one tool)
@@ -576,6 +619,76 @@ const federationStatusTool = defineTool("federation_status", "Federation skeleto
     }
 }, { readOnlyHint: true });
 // ---------------------------------------------------------------------------
+// Pillar A — session heartbeat + cron tools
+// ---------------------------------------------------------------------------
+/** In-memory store for active heartbeats started via the MCP tool.
+ *  Maps sessionId → stop fn. Only used by the MCP surface; the JSONL
+ *  file is the authoritative persistence. */
+const _activeHeartbeats = new Map();
+const sessionHeartbeatTool = defineTool("session_heartbeat", "Start, stop, or fail a session heartbeat. start returns a sessionId. Stop/fail write a terminal record to .harness/traces/heartbeat.jsonl.", { action: "string", sessionId: "string", intervalMs: "number" }, async ({ action, sessionId, intervalMs }) => {
+    try {
+        if (action === "start") {
+            const { sessionId: id, stop } = startHeartbeat(intervalMs ?? 30_000);
+            _activeHeartbeats.set(id, stop);
+            return ok(JSON.stringify({ sessionId: id }));
+        }
+        if (action === "stop") {
+            const id = sessionId ?? "";
+            const stop = _activeHeartbeats.get(id);
+            if (stop) {
+                stop();
+                _activeHeartbeats.delete(id);
+            }
+            else {
+                stopHeartbeat(id);
+            }
+            return ok(JSON.stringify({ sessionId: id ?? "", status: "done" }));
+        }
+        if (action === "fail") {
+            const id = sessionId ?? "";
+            const stop = _activeHeartbeats.get(id);
+            if (stop) {
+                stop();
+                _activeHeartbeats.delete(id);
+            }
+            else {
+                failHeartbeat(id);
+            }
+            return ok(JSON.stringify({ sessionId: id ?? "", status: "failed" }));
+        }
+        return err(`unknown_action: ${action}`);
+    }
+    catch (e) {
+        return err(String(e));
+    }
+});
+const cronAddTool = defineTool("cron_add", "Add a cron task. Persists to .bizar/cron.json. recurring=false tasks fire once and are then removed.", { cron: "string", prompt: "string", recurring: "boolean" }, async ({ cron, prompt, recurring }) => {
+    try {
+        const task = addCronTask({ cron, prompt, recurring: recurring ?? false });
+        return ok(JSON.stringify(task, null, 2));
+    }
+    catch (e) {
+        return err(String(e));
+    }
+});
+const cronListTool = defineTool("cron_list", "List all cron tasks from .bizar/cron.json.", {}, async () => {
+    try {
+        return ok(JSON.stringify(listCronTasks(), null, 2));
+    }
+    catch (e) {
+        return err(String(e));
+    }
+}, { readOnlyHint: true });
+const cronRemoveTool = defineTool("cron_remove", "Remove a cron task by its id. Returns true if the task existed.", { id: "string" }, async ({ id }) => {
+    try {
+        const removed = removeCronTask(id);
+        return ok(JSON.stringify({ id, removed }));
+    }
+    catch (e) {
+        return err(String(e));
+    }
+});
+// ---------------------------------------------------------------------------
 // Factory — wire all tools into an MCP server
 // ---------------------------------------------------------------------------
 export const BIZAR_TOOLS = [
@@ -600,8 +713,13 @@ export const BIZAR_TOOLS = [
     agentRouteTool,
     memoryDistillTool,
     hooksRouteTool,
+    routeAgentTool,
     consensusProposeTool,
     federationStatusTool,
+    sessionHeartbeatTool,
+    cronAddTool,
+    cronListTool,
+    cronRemoveTool,
 ];
 /**
  * Build the Bizar MCP server config. Pass this into Claude Code's

package/packages/sdk/dist/router/agent-model-registry.d.ts

@@ -0,0 +1,89 @@
+/**
+ * router/agent-model-registry.ts — resolve agent → concrete model ID.
+ *
+ * v10.1.0 — Reads `.claude/model-router.json` (the Bizar model registry)
+ * and exposes:
+ *
+ *   - resolveAgentModel(agent)         → { modelId, tier, endpoint, rationale }
+ *   - listAgentModels()                → Array<{ agent, modelId, tier, ... }>
+ *   - resolveTierModel(tier)           → { modelId, endpoint, fallback[] }
+ *   - getEndpoint()                    → endpoint URL (env override honored)
+ *
+ * The router decides which tier; this registry decides which concrete
+ * model ID lives at that tier and which endpoint URL to call. Together
+ * they form the dispatch contract the MCP `route_agent` tool surfaces.
+ *
+ * Why a separate module: the Thompson-bandit model-router.ts doesn't
+ * know about model IDs (it only reasons about `flash / mid / expensive`
+ * priors). The agent-registry.ts knows about agent types but not about
+ * concrete models. This module is the bridge.
+ */
+export type BizarTier = "premium" | "high" | "mid-design" | "default" | "mid" | "budget";
+export interface AgentModelEntry {
+    agent: string;
+    modelId: string;
+    tier: BizarTier;
+    rationale: string;
+}
+export interface TierModelEntry {
+    tier: BizarTier;
+    modelIds: string[];
+    purpose: string;
+}
+export interface ResolvedAgentModel {
+    agent: string;
+    modelId: string;
+    tier: BizarTier;
+    endpoint: string;
+    rationale: string;
+}
+export interface ResolvedTierModel {
+    tier: BizarTier;
+    modelId: string;
+    fallback: string[];
+    endpoint: string;
+    purpose: string;
+}
+export interface ModelRegistry {
+    endpoint: string;
+    agents: Map<string, AgentModelEntry>;
+    tiers: Map<BizarTier, TierModelEntry>;
+    fallbackChain: string[];
+    gptOnlyFor: string[];
+    gptNeverFor: string[];
+}
+export interface RegistrySource {
+    /** Path to `model-router.json`. Default: `.claude/model-router.json`. */
+    configPath?: string;
+    /** Override the endpoint URL (otherwise read from the JSON). */
+    endpoint?: string;
+}
+/**
+ * Read the registry from disk. Tolerates a missing/corrupt file by
+ * returning a minimal registry pointing at the local router default —
+ * agents can still operate, just without the per-agent rationale data.
+ */
+export declare function loadModelRegistry(src?: RegistrySource): ModelRegistry;
+/**
+ * Resolve the concrete model + endpoint for a named agent.
+ * Falls back to the default agent entry (or a hard-coded `bizar/MiniMax-M3`
+ * if even the default is missing) so a call always returns something
+ * usable. Never throws.
+ */
+export declare function resolveAgentModel(agent: string, reg: ModelRegistry): ResolvedAgentModel;
+/**
+ * Resolve a tier to its primary model ID + the fallback chain. Always
+ * returns at least one model ID.
+ */
+export declare function resolveTierModel(tier: BizarTier, reg: ModelRegistry): ResolvedTierModel;
+/**
+ * Return the full agent → model table. Stable order: insertion order from
+ * the JSON (preserves whatever order the operator wrote).
+ */
+export declare function listAgentModels(reg: ModelRegistry): AgentModelEntry[];
+/**
+ * Convenience: read the endpoint from the registry / env. Useful in
+ * scripts that don't want to load the full registry just for a URL.
+ */
+export declare function getEndpoint(reg?: ModelRegistry): string;
+//# sourceMappingURL=agent-model-registry.d.ts.map

package/packages/sdk/dist/router/agent-model-registry.js

@@ -0,0 +1,144 @@
+/**
+ * router/agent-model-registry.ts — resolve agent → concrete model ID.
+ *
+ * v10.1.0 — Reads `.claude/model-router.json` (the Bizar model registry)
+ * and exposes:
+ *
+ *   - resolveAgentModel(agent)         → { modelId, tier, endpoint, rationale }
+ *   - listAgentModels()                → Array<{ agent, modelId, tier, ... }>
+ *   - resolveTierModel(tier)           → { modelId, endpoint, fallback[] }
+ *   - getEndpoint()                    → endpoint URL (env override honored)
+ *
+ * The router decides which tier; this registry decides which concrete
+ * model ID lives at that tier and which endpoint URL to call. Together
+ * they form the dispatch contract the MCP `route_agent` tool surfaces.
+ *
+ * Why a separate module: the Thompson-bandit model-router.ts doesn't
+ * know about model IDs (it only reasons about `flash / mid / expensive`
+ * priors). The agent-registry.ts knows about agent types but not about
+ * concrete models. This module is the bridge.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { isAbsolute, resolve } from "node:path";
+const DEFAULT_CONFIG = ".claude/model-router.json";
+const KNOWN_TIERS = [
+    "premium",
+    "high",
+    "mid-design",
+    "default",
+    "mid",
+    "budget",
+];
+function isKnownTier(t) {
+    return typeof t === "string" && KNOWN_TIERS.includes(t);
+}
+/**
+ * Read the registry from disk. Tolerates a missing/corrupt file by
+ * returning a minimal registry pointing at the local router default —
+ * agents can still operate, just without the per-agent rationale data.
+ */
+export function loadModelRegistry(src = {}) {
+    const fp = src.configPath
+        ? isAbsolute(src.configPath) ? src.configPath : resolve(src.configPath)
+        : resolve(DEFAULT_CONFIG);
+    let raw = {};
+    if (existsSync(fp)) {
+        try {
+            raw = JSON.parse(readFileSync(fp, "utf8"));
+        }
+        catch {
+            raw = {};
+        }
+    }
+    const endpoint = src.endpoint
+        ?? process.env.BIZAR_MODEL_ROUTER_URL
+        ?? process.env.ANTHROPIC_BASE_URL
+        ?? raw.endpoint
+        ?? "http://localhost:20128/v1";
+    const agents = new Map();
+    if (raw.agents && typeof raw.agents === "object") {
+        for (const [name, def] of Object.entries(raw.agents)) {
+            if (!def || typeof def !== "object")
+                continue;
+            const modelId = typeof def.model === "string" ? def.model : "bizar/MiniMax-M3";
+            const tier = isKnownTier(def.tier) ? def.tier : "default";
+            const rationale = typeof def.rationale === "string" ? def.rationale : "";
+            agents.set(name, { agent: name, modelId, tier, rationale });
+        }
+    }
+    const tiers = new Map();
+    if (raw.tiers && typeof raw.tiers === "object") {
+        for (const [name, def] of Object.entries(raw.tiers)) {
+            if (!def || typeof def !== "object")
+                continue;
+            if (!isKnownTier(name))
+                continue;
+            const ids = Array.isArray(def.models) ? def.models.filter((m) => typeof m === "string") : [];
+            const purpose = typeof def.purpose === "string" ? def.purpose : "";
+            tiers.set(name, { tier: name, modelIds: ids, purpose });
+        }
+    }
+    const fallbackChain = Array.isArray(raw.policies?.fallback_chain)
+        ? raw.policies.fallback_chain.filter((m) => typeof m === "string")
+        : [];
+    const gptOnlyFor = Array.isArray(raw.policies?.gpt_only_for)
+        ? raw.policies.gpt_only_for.filter((s) => typeof s === "string")
+        : [];
+    const gptNeverFor = Array.isArray(raw.policies?.gpt_never_for)
+        ? raw.policies.gpt_never_for.filter((s) => typeof s === "string")
+        : [];
+    return { endpoint, agents, tiers, fallbackChain, gptOnlyFor, gptNeverFor };
+}
+/**
+ * Resolve the concrete model + endpoint for a named agent.
+ * Falls back to the default agent entry (or a hard-coded `bizar/MiniMax-M3`
+ * if even the default is missing) so a call always returns something
+ * usable. Never throws.
+ */
+export function resolveAgentModel(agent, reg) {
+    const entry = reg.agents.get(agent)
+        ?? reg.agents.get("odin")
+        ?? { agent: "odin", modelId: "bizar/MiniMax-M3", tier: "default", rationale: "fallback" };
+    return {
+        agent: entry.agent,
+        modelId: entry.modelId,
+        tier: entry.tier,
+        endpoint: reg.endpoint,
+        rationale: entry.rationale,
+    };
+}
+/**
+ * Resolve a tier to its primary model ID + the fallback chain. Always
+ * returns at least one model ID.
+ */
+export function resolveTierModel(tier, reg) {
+    const entry = reg.tiers.get(tier);
+    const primary = entry?.modelIds[0] ?? "bizar/MiniMax-M3";
+    const fallback = entry?.modelIds.slice(1) ?? [];
+    return {
+        tier,
+        modelId: primary,
+        fallback,
+        endpoint: reg.endpoint,
+        purpose: entry?.purpose ?? "",
+    };
+}
+/**
+ * Return the full agent → model table. Stable order: insertion order from
+ * the JSON (preserves whatever order the operator wrote).
+ */
+export function listAgentModels(reg) {
+    return Array.from(reg.agents.values());
+}
+/**
+ * Convenience: read the endpoint from the registry / env. Useful in
+ * scripts that don't want to load the full registry just for a URL.
+ */
+export function getEndpoint(reg) {
+    if (reg)
+        return reg.endpoint;
+    return process.env.BIZAR_MODEL_ROUTER_URL
+        ?? process.env.ANTHROPIC_BASE_URL
+        ?? "http://localhost:20128/v1";
+}
+//# sourceMappingURL=agent-model-registry.js.map

package/packages/sdk/dist/router/index.d.ts

@@ -97,4 +97,5 @@ export { detectCodemodIntent, CODEMOD_CONFIDENCE_THRESHOLD, } from "./codemod-in
 export type { CodemodIntent, CodemodIntentHit } from "./codemod-intent.js";
 export { ModelRouter, type ModelTier, type RouteDecision, } from "./model-router.js";
 export { QLearningRouter, AGENT_ACTIONS, type AgentName, type AgentRouteDecision, } from "./q-learning-router.js";
+export { loadModelRegistry, resolveAgentModel, resolveTierModel, listAgentModels, getEndpoint, type ModelRegistry, type ResolvedAgentModel, type ResolvedTierModel, type AgentModelEntry, type TierModelEntry, type BizarTier, } from "./agent-model-registry.js";
 //# sourceMappingURL=index.d.ts.map

package/packages/sdk/dist/router/index.js

@@ -146,4 +146,5 @@ export function tierTag(decision) {
 export { detectCodemodIntent, CODEMOD_CONFIDENCE_THRESHOLD, } from "./codemod-intent.js";
 export { ModelRouter, } from "./model-router.js";
 export { QLearningRouter, AGENT_ACTIONS, } from "./q-learning-router.js";
+export { loadModelRegistry, resolveAgentModel, resolveTierModel, listAgentModels, getEndpoint, } from "./agent-model-registry.js";
 //# sourceMappingURL=index.js.map

package/packages/sdk/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polderlabs/bizar-sdk",
-  "version": "10.1.0",
+  "version": "10.3.0",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -11,7 +11,8 @@
     ".": "./dist/index.js",
     "./memory": "./dist/memory/index.js",
     "./mcp": "./dist/mcp/server.js",
-    "./dangerous-patterns": "./dist/dangerous-patterns.js"
+    "./dangerous-patterns": "./dist/dangerous-patterns.js",
+    "./learning": "./dist/learning/index.js"
   },
   "files": [
     "dist"