moltblock 0.3.1 → 0.5.0

package/dist/agents.d.ts

@@ -21,4 +21,3 @@ export declare function runJudge(gateway: LLMGateway, memory: WorkingMemory, sto
  * Returns the role's output string. Used by the graph runner.
  */
 export declare function runRole(role: string, gateway: LLMGateway, task: string, inputs: Record<string, string>, longTermContext?: string, store?: Store | null): Promise<string>;
-//# sourceMappingURL=agents.d.ts.map

package/dist/agents.js

@@ -121,4 +121,3 @@ export async function runRole(role, gateway, task, inputs, longTermContext = "",
     }
     throw new Error(`Unknown role for graph: ${role}`);
 }
-//# sourceMappingURL=agents.js.map

package/dist/cli.d.ts

@@ -3,4 +3,3 @@
  * CLI: run one Code Entity task.
  */
 export {};
-//# sourceMappingURL=cli.d.ts.map

package/dist/cli.js

@@ -14,6 +14,8 @@ async function main() {
         .argument("<task>", "Task description (e.g. 'Implement a function add(a,b) that returns a+b.')")
         .option("-t, --test <path>", "Path to file containing test code (e.g. vitest test module). If omitted, only syntax check.")
         .option("--json", "Output result as JSON (draft, critique, final, verification_passed, authoritative_artifact).")
+        .option("-p, --provider <name>", "LLM provider (openai, google, zai, local). Auto-detected from env if omitted.")
+        .option("-m, --model <name>", "Model for all roles (overrides provider default).")
         .action(async (task, options) => {
         // Validate task input
         const validation = validateTask(task);
@@ -30,7 +32,10 @@ async function main() {
         if (options.test && fs.existsSync(options.test)) {
             testCode = fs.readFileSync(options.test, "utf-8");
         }
-        const entity = new CodeEntity(defaultCodeEntityBindings());
+        const entity = new CodeEntity(defaultCodeEntityBindings({
+            provider: options.provider,
+            model: options.model,
+        }));
         const memory = await entity.run(task, { testCode });
         if (options.json) {
             const out = {
@@ -67,4 +72,3 @@ main().catch((err) => {
     console.error(err);
     process.exit(1);
 });
-//# sourceMappingURL=cli.js.map

package/dist/config.d.ts

@@ -8,17 +8,7 @@ export declare const BindingEntrySchema: z.ZodObject<{
     base_url: z.ZodString;
     model: z.ZodDefault<z.ZodString>;
     api_key: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-}, "strip", z.ZodTypeAny, {
-    model: string;
-    backend: string;
-    base_url: string;
-    api_key?: string | null | undefined;
-}, {
-    backend: string;
-    base_url: string;
-    model?: string | undefined;
-    api_key?: string | null | undefined;
-}>;
+}, z.core.$strip>;
 export type BindingEntry = z.infer<typeof BindingEntrySchema>;
 export declare const AgentConfigSchema: z.ZodObject<{
     bindings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
@@ -26,32 +16,8 @@ export declare const AgentConfigSchema: z.ZodObject<{
         base_url: z.ZodString;
         model: z.ZodDefault<z.ZodString>;
         api_key: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    }, "strip", z.ZodTypeAny, {
-        model: string;
-        backend: string;
-        base_url: string;
-        api_key?: string | null | undefined;
-    }, {
-        backend: string;
-        base_url: string;
-        model?: string | undefined;
-        api_key?: string | null | undefined;
-    }>>>;
-}, "strip", z.ZodTypeAny, {
-    bindings?: Record<string, {
-        model: string;
-        backend: string;
-        base_url: string;
-        api_key?: string | null | undefined;
-    }> | undefined;
-}, {
-    bindings?: Record<string, {
-        backend: string;
-        base_url: string;
-        model?: string | undefined;
-        api_key?: string | null | undefined;
-    }> | undefined;
-}>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
 export type AgentConfig = z.infer<typeof AgentConfigSchema>;
 export declare const MoltblockConfigSchema: z.ZodObject<{
     agent: z.ZodOptional<z.ZodObject<{
@@ -60,68 +26,16 @@ export declare const MoltblockConfigSchema: z.ZodObject<{
             base_url: z.ZodString;
             model: z.ZodDefault<z.ZodString>;
             api_key: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        }, "strip", z.ZodTypeAny, {
-            model: string;
-            backend: string;
-            base_url: string;
-            api_key?: string | null | undefined;
-        }, {
-            backend: string;
-            base_url: string;
-            model?: string | undefined;
-            api_key?: string | null | undefined;
-        }>>>;
-    }, "strip", z.ZodTypeAny, {
-        bindings?: Record<string, {
-            model: string;
-            backend: string;
-            base_url: string;
-            api_key?: string | null | undefined;
-        }> | undefined;
-    }, {
-        bindings?: Record<string, {
-            backend: string;
-            base_url: string;
-            model?: string | undefined;
-            api_key?: string | null | undefined;
-        }> | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    agent?: {
-        bindings?: Record<string, {
-            model: string;
-            backend: string;
-            base_url: string;
-            api_key?: string | null | undefined;
-        }> | undefined;
-    } | undefined;
-}, {
-    agent?: {
-        bindings?: Record<string, {
-            backend: string;
-            base_url: string;
-            model?: string | undefined;
-            api_key?: string | null | undefined;
-        }> | undefined;
-    } | undefined;
-}>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export type MoltblockConfig = z.infer<typeof MoltblockConfigSchema>;
 export declare const ModelBindingSchema: z.ZodObject<{
     backend: z.ZodString;
     baseUrl: z.ZodString;
     apiKey: z.ZodDefault<z.ZodNullable<z.ZodString>>;
     model: z.ZodDefault<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    model: string;
-    backend: string;
-    baseUrl: string;
-    apiKey: string | null;
-}, {
-    backend: string;
-    baseUrl: string;
-    model?: string | undefined;
-    apiKey?: string | null | undefined;
-}>;
+}, z.core.$strip>;
 export type ModelBinding = z.infer<typeof ModelBindingSchema>;
 /** Track which config source was used */
 export type ConfigSource = "moltblock" | "openclaw" | "env" | null;
@@ -134,9 +48,23 @@ export declare function getConfigSource(): ConfigSource;
  * Returns null if no file or parse error.
  */
 export declare function loadMoltblockConfig(): MoltblockConfig | null;
+/** Overrides for provider/model selection (e.g. from CLI flags). */
+export interface BindingOverrides {
+    provider?: string;
+    model?: string;
+}
+/**
+ * Auto-detect the best available provider from environment variables.
+ * Priority: explicit override > OPENAI_API_KEY > GOOGLE_API_KEY > MOLTBLOCK_ZAI_API_KEY/ZAI_API_KEY > local.
+ */
+export declare function detectProvider(overrideProvider?: string, overrideModel?: string): {
+    backend: string;
+    baseUrl: string;
+    model: string;
+    apiKey: string | null;
+};
 /**
  * Model bindings for Code Entity. Load from moltblock.json if present, then env overrides.
- * If no JSON, uses env/.env only (backward compatible). API keys from env win over JSON.
+ * If no JSON, auto-detects provider from env vars. API keys from env win over JSON.
  */
-export declare function defaultCodeEntityBindings(): Record<string, ModelBinding>;
-//# sourceMappingURL=config.d.ts.map
+export declare function defaultCodeEntityBindings(overrides?: BindingOverrides): Record<string, ModelBinding>;

package/dist/config.js

@@ -6,14 +6,30 @@ import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
 import { z } from "zod";
+/** JSON.parse reviver that strips prototype pollution keys */
+function safeJsonParse(text) {
+    return JSON.parse(text, (key, value) => {
+        if (key === "__proto__" || key === "constructor" || key === "prototype") {
+            return undefined;
+        }
+        return value;
+    });
+}
 // Load .env so MOLTBLOCK_ZAI_API_KEY etc. can be set there
 try {
     const dotenv = await import("dotenv");
-    dotenv.config();
+    dotenv.config({ quiet: true });
 }
 catch {
     // dotenv not required
 }
+// --- Provider defaults registry ---
+const PROVIDER_DEFAULTS = {
+    openai: { baseUrl: "https://api.openai.com/v1", model: "gpt-4o", envKey: "OPENAI_API_KEY" },
+    google: { baseUrl: "https://generativelanguage.googleapis.com/v1beta/openai/", model: "gemini-2.0-flash", envKey: "GOOGLE_API_KEY" },
+    zai: { baseUrl: "https://api.z.ai/api/paas/v4", model: "glm-4.7-flash", envKey: "MOLTBLOCK_ZAI_API_KEY" },
+    local: { baseUrl: "http://localhost:1234/v1", model: "local", envKey: "" },
+};
 // --- Zod schemas (OpenClaw-style config) ---
 export const BindingEntrySchema = z.object({
     backend: z.string().describe("e.g. 'local' or 'zai' or 'openai'"),
@@ -22,7 +38,7 @@ export const BindingEntrySchema = z.object({
     api_key: z.string().nullable().optional().describe("Bearer token; null for local. Prefer env."),
 });
 export const AgentConfigSchema = z.object({
-    bindings: z.record(BindingEntrySchema).optional().describe("Per-role model bindings"),
+    bindings: z.record(z.string(), BindingEntrySchema).optional().describe("Per-role model bindings"),
 });
 export const MoltblockConfigSchema = z.object({
     agent: AgentConfigSchema.optional().describe("Agent defaults and bindings"),
@@ -33,12 +49,18 @@ export const ModelBindingSchema = z.object({
     apiKey: z.string().nullable().default(null).describe("Bearer token; null for local"),
     model: z.string().default("default").describe("Model name for chat completion"),
 });
+/** Validate that a config path is within allowed directories (cwd, homedir, or tmpdir). */
+function isAllowedConfigPath(filePath) {
+    const resolved = path.resolve(filePath);
+    const allowed = [path.resolve(process.cwd()), path.resolve(os.homedir()), path.resolve(os.tmpdir())];
+    return allowed.some((dir) => resolved.startsWith(dir + path.sep) || resolved === dir);
+}
 /**
  * Resolve moltblock config file: MOLTBLOCK_CONFIG env, then ./moltblock.json, ./.moltblock/moltblock.json, ~/.moltblock/moltblock.json.
  */
 function moltblockConfigPath() {
     const envPath = (process.env["MOLTBLOCK_CONFIG"] ?? "").trim();
-    if (envPath && fs.existsSync(envPath)) {
+    if (envPath && isAllowedConfigPath(envPath) && fs.existsSync(envPath)) {
         return envPath;
     }
     const cwd = process.cwd();
@@ -59,7 +81,7 @@ function moltblockConfigPath() {
  */
 function openclawConfigPath() {
     const envPath = (process.env["OPENCLAW_CONFIG"] ?? "").trim();
-    if (envPath && fs.existsSync(envPath)) {
+    if (envPath && isAllowedConfigPath(envPath) && fs.existsSync(envPath)) {
         return envPath;
     }
     const cwd = process.cwd();
@@ -92,7 +114,7 @@ export function loadMoltblockConfig() {
     if (moltblockFile) {
         try {
             const raw = fs.readFileSync(moltblockFile, "utf-8");
-            const data = JSON.parse(raw);
+            const data = safeJsonParse(raw);
             const config = MoltblockConfigSchema.parse(data);
             lastConfigSource = "moltblock";
             return config;
@@ -106,7 +128,7 @@ export function loadMoltblockConfig() {
     if (openclawFile) {
         try {
             const raw = fs.readFileSync(openclawFile, "utf-8");
-            const data = JSON.parse(raw);
+            const data = safeJsonParse(raw);
             const config = parseOpenClawConfig(data);
             if (config) {
                 lastConfigSource = "openclaw";
@@ -123,18 +145,49 @@ export function loadMoltblockConfig() {
 }
 /**
  * Parse OpenClaw config and convert to MoltblockConfig format.
- * OpenClaw uses a similar structure but may have different field names.
+ * Handles multiple OpenClaw formats: agents.defaults.model.primary ("provider/model"),
+ * agent.bindings, providers section, and models section.
  */
 function parseOpenClawConfig(data) {
     if (!data || typeof data !== "object") {
         return null;
     }
     const obj = data;
-    // OpenClaw may have agent.bindings or providers section
-    // Try to extract bindings from various possible locations
     let bindings;
+    // Check for agents.defaults.model.primary (OpenClaw's actual format: "provider/model")
+    if (obj["agents"] && typeof obj["agents"] === "object") {
+        const agents = obj["agents"];
+        if (agents["defaults"] && typeof agents["defaults"] === "object") {
+            const defaults = agents["defaults"];
+            if (defaults["model"] && typeof defaults["model"] === "object") {
+                const modelConfig = defaults["model"];
+                const primary = modelConfig["primary"];
+                if (typeof primary === "string" && primary.includes("/")) {
+                    const parts = primary.split("/");
+                    const providerName = parts[0] ?? "";
+                    const modelName = parts.slice(1).join("/");
+                    const provider = PROVIDER_DEFAULTS[providerName.toLowerCase()];
+                    if (providerName && provider) {
+                        const apiKey = getApiKeyForBackend(providerName);
+                        const binding = {
+                            backend: providerName.toLowerCase(),
+                            base_url: provider.baseUrl,
+                            model: modelName || provider.model,
+                            api_key: apiKey,
+                        };
+                        bindings = {
+                            generator: binding,
+                            critic: { ...binding },
+                            judge: { ...binding },
+                            verifier: { ...binding },
+                        };
+                    }
+                }
+            }
+        }
+    }
     // Check for agent.bindings (same as moltblock)
-    if (obj["agent"] && typeof obj["agent"] === "object") {
+    if (!bindings && obj["agent"] && typeof obj["agent"] === "object") {
         const agent = obj["agent"];
         if (agent["bindings"] && typeof agent["bindings"] === "object") {
             bindings = extractBindings(agent["bindings"]);
@@ -227,70 +280,88 @@ function getApiKeyForBackend(backend) {
         return env("GOOGLE_API_KEY") || null;
     }
     if (backendLower === "zai") {
-        return env("MOLTBLOCK_ZAI_API_KEY") || null;
+        return env("MOLTBLOCK_ZAI_API_KEY") || env("ZAI_API_KEY") || null;
     }
     return null;
 }
+/**
+ * Auto-detect the best available provider from environment variables.
+ * Priority: explicit override > OPENAI_API_KEY > GOOGLE_API_KEY > MOLTBLOCK_ZAI_API_KEY/ZAI_API_KEY > local.
+ */
+export function detectProvider(overrideProvider, overrideModel) {
+    if (overrideProvider) {
+        const p = PROVIDER_DEFAULTS[overrideProvider.toLowerCase()];
+        if (!p) {
+            throw new Error(`Unknown provider "${overrideProvider}". Valid providers: ${Object.keys(PROVIDER_DEFAULTS).join(", ")}`);
+        }
+        const apiKey = p.envKey ? env(p.envKey) || null : null;
+        return {
+            backend: overrideProvider.toLowerCase(),
+            baseUrl: p.baseUrl,
+            model: overrideModel || p.model,
+            apiKey,
+        };
+    }
+    // Scan env vars in priority order
+    const priority = [
+        { name: "openai", envKey: "OPENAI_API_KEY" },
+        { name: "google", envKey: "GOOGLE_API_KEY" },
+        { name: "zai", envKey: "MOLTBLOCK_ZAI_API_KEY" },
+        { name: "zai", envKey: "ZAI_API_KEY" },
+    ];
+    for (const { name, envKey } of priority) {
+        const key = env(envKey);
+        if (key) {
+            const p = PROVIDER_DEFAULTS[name];
+            return {
+                backend: name,
+                baseUrl: p.baseUrl,
+                model: overrideModel || p.model,
+                apiKey: key,
+            };
+        }
+    }
+    // Fallback to local
+    const local = PROVIDER_DEFAULTS["local"];
+    return {
+        backend: "local",
+        baseUrl: local.baseUrl,
+        model: overrideModel || local.model,
+        apiKey: null,
+    };
+}
 /**
  * Model bindings for Code Entity. Load from moltblock.json if present, then env overrides.
- * If no JSON, uses env/.env only (backward compatible). API keys from env win over JSON.
+ * If no JSON, auto-detects provider from env vars. API keys from env win over JSON.
  */
-export function defaultCodeEntityBindings() {
+export function defaultCodeEntityBindings(overrides) {
     const cfg = loadMoltblockConfig();
-    const zaiKey = env("MOLTBLOCK_ZAI_API_KEY");
-    const localUrl = env("MOLTBLOCK_GENERATOR_BASE_URL") || "http://localhost:1234/v1";
-    const localModel = env("MOLTBLOCK_GENERATOR_MODEL") || "local";
     const envUrl = (key, fallback) => env(key) || fallback;
     const envModel = (key, fallback) => env(key) || fallback;
     const bindingsFromJson = cfg?.agent?.bindings ?? {};
-    function bindingFor(role, defaultBackend, defaultBase, defaultModel, defaultApiKey) {
+    function bindingFor(role) {
         const entry = bindingsFromJson[role];
         if (entry) {
             const baseUrl = envUrl(`MOLTBLOCK_${role.toUpperCase()}_BASE_URL`, entry.base_url);
             const model = envModel(`MOLTBLOCK_${role.toUpperCase()}_MODEL`, entry.model ?? "default");
-            const apiKey = env(`MOLTBLOCK_${role.toUpperCase()}_API_KEY`) ||
-                entry.api_key ||
-                getApiKeyForBackend(entry.backend) ||
-                null;
+            const envApiKey = env(`MOLTBLOCK_${role.toUpperCase()}_API_KEY`);
+            if (!envApiKey && entry.api_key) {
+                console.warn(`Warning: API key for "${role}" loaded from config file. ` +
+                    `Use environment variables instead for better security.`);
+            }
+            const apiKey = envApiKey || entry.api_key || getApiKeyForBackend(entry.backend) || null;
             return { backend: entry.backend, baseUrl, apiKey, model };
         }
-        // No JSON: legacy env-only behavior
-        if (role === "generator") {
-            return { backend: "local", baseUrl: localUrl, apiKey: null, model: localModel };
-        }
-        if (role === "critic") {
-            const useZai = Boolean(zaiKey);
-            return {
-                backend: useZai ? "zai" : "local",
-                baseUrl: envUrl("MOLTBLOCK_CRITIC_BASE_URL", useZai ? "https://api.z.ai/api/paas/v4" : localUrl),
-                apiKey: useZai ? zaiKey : null,
-                model: envModel("MOLTBLOCK_CRITIC_MODEL", useZai ? "glm-4.7-flash" : localModel),
-            };
-        }
-        if (role === "judge") {
-            const useZai = Boolean(zaiKey);
-            return {
-                backend: useZai ? "zai" : "local",
-                baseUrl: envUrl("MOLTBLOCK_JUDGE_BASE_URL", useZai ? "https://api.z.ai/api/paas/v4" : localUrl),
-                apiKey: useZai ? zaiKey : null,
-                model: envModel("MOLTBLOCK_JUDGE_MODEL", useZai ? "glm-4.7-flash" : localModel),
-            };
-        }
-        if (role === "verifier") {
-            return {
-                backend: "local",
-                baseUrl: envUrl("MOLTBLOCK_VERIFIER_BASE_URL", localUrl),
-                apiKey: null,
-                model: envModel("MOLTBLOCK_VERIFIER_MODEL", localModel),
-            };
-        }
-        return { backend: defaultBackend, baseUrl: defaultBase, apiKey: defaultApiKey, model: defaultModel };
+        // No JSON entry for this role: auto-detect provider
+        const detected = detectProvider(overrides?.provider, overrides?.model);
+        const baseUrl = envUrl(`MOLTBLOCK_${role.toUpperCase()}_BASE_URL`, detected.baseUrl);
+        const model = envModel(`MOLTBLOCK_${role.toUpperCase()}_MODEL`, detected.model);
+        return { backend: detected.backend, baseUrl, apiKey: detected.apiKey, model };
     }
     return {
-        generator: bindingFor("generator", "local", localUrl, localModel, null),
-        critic: bindingFor("critic", zaiKey ? "zai" : "local", localUrl, localModel, zaiKey || null),
-        judge: bindingFor("judge", zaiKey ? "zai" : "local", localUrl, localModel, zaiKey || null),
-        verifier: bindingFor("verifier", "local", localUrl, localModel, null),
+        generator: bindingFor("generator"),
+        critic: bindingFor("critic"),
+        judge: bindingFor("judge"),
+        verifier: bindingFor("verifier"),
     };
 }
-//# sourceMappingURL=config.js.map

package/dist/entity.d.ts

@@ -28,4 +28,3 @@ export declare class CodeEntity {
  * Load an Entity from a declarative graph (JSON/YAML). Returns a GraphRunner.
  */
 export declare function loadEntityWithGraph(graphPath: string, bindings?: Record<string, ModelBinding>): GraphRunner;
-//# sourceMappingURL=entity.d.ts.map

package/dist/entity.js

@@ -89,4 +89,3 @@ export function loadEntityWithGraph(graphPath, bindings) {
     const graph = AgentGraph.load(graphPath);
     return new GraphRunner(graph, bindings);
 }
-//# sourceMappingURL=entity.js.map

package/dist/gateway.d.ts

@@ -17,4 +17,3 @@ export declare class LLMGateway {
      */
     complete(messages: ChatMessage[], maxTokens?: number): Promise<string>;
 }
-//# sourceMappingURL=gateway.d.ts.map

package/dist/gateway.js

@@ -61,4 +61,3 @@ export class LLMGateway {
         return choice.message.content ?? "";
     }
 }
-//# sourceMappingURL=gateway.js.map

package/dist/governance.d.ts

@@ -43,4 +43,3 @@ export declare function isPaused(store: Store): boolean;
  * Record emergency shutdown in audit log.
  */
 export declare function emergencyShutdown(store: Store): void;
-//# sourceMappingURL=governance.d.ts.map

package/dist/governance.js

@@ -84,4 +84,3 @@ export function isPaused(store) {
 export function emergencyShutdown(store) {
     auditLog(store, "emergency_shutdown", "");
 }
-//# sourceMappingURL=governance.js.map

package/dist/graph-runner.d.ts

@@ -25,4 +25,3 @@ export declare class GraphRunner {
         writeCheckpointAfter?: boolean;
     }): Promise<WorkingMemory>;
 }
-//# sourceMappingURL=graph-runner.d.ts.map

package/dist/graph-runner.js

@@ -100,4 +100,3 @@ export class GraphRunner {
         return memory;
     }
 }
-//# sourceMappingURL=graph-runner.js.map

package/dist/graph-schema.d.ts

@@ -6,75 +6,25 @@ export declare const GraphNodeSchema: z.ZodObject<{
     id: z.ZodString;
     role: z.ZodString;
     binding: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-    role: string;
-    binding: string;
-}, {
-    id: string;
-    role: string;
-    binding: string;
-}>;
+}, z.core.$strip>;
 export type GraphNode = z.infer<typeof GraphNodeSchema>;
 export declare const GraphEdgeSchema: z.ZodObject<{
     from: z.ZodString;
     to: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    from: string;
-    to: string;
-}, {
-    from: string;
-    to: string;
-}>;
+}, z.core.$strip>;
 export type GraphEdge = z.infer<typeof GraphEdgeSchema>;
 export declare const AgentGraphSchema: z.ZodObject<{
     nodes: z.ZodDefault<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         role: z.ZodString;
         binding: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        id: string;
-        role: string;
-        binding: string;
-    }, {
-        id: string;
-        role: string;
-        binding: string;
-    }>, "many">>;
+    }, z.core.$strip>>>;
     edges: z.ZodDefault<z.ZodArray<z.ZodObject<{
         from: z.ZodString;
         to: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        from: string;
-        to: string;
-    }, {
-        from: string;
-        to: string;
-    }>, "many">>;
+    }, z.core.$strip>>>;
     final_node: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-}, "strip", z.ZodTypeAny, {
-    nodes: {
-        id: string;
-        role: string;
-        binding: string;
-    }[];
-    edges: {
-        from: string;
-        to: string;
-    }[];
-    final_node?: string | null | undefined;
-}, {
-    nodes?: {
-        id: string;
-        role: string;
-        binding: string;
-    }[] | undefined;
-    edges?: {
-        from: string;
-        to: string;
-    }[] | undefined;
-    final_node?: string | null | undefined;
-}>;
+}, z.core.$strip>;
 export type AgentGraphData = z.infer<typeof AgentGraphSchema>;
 /**
  * Declarative agent graph: nodes and edges. Verifier runs on final node(s) output.
@@ -113,4 +63,3 @@ export declare class AgentGraph {
      */
     static fromData(data: AgentGraphData): AgentGraph;
 }
-//# sourceMappingURL=graph-schema.d.ts.map

package/dist/graph-schema.js

@@ -134,4 +134,3 @@ export class AgentGraph {
         return new AgentGraph(AgentGraphSchema.parse(data));
     }
 }
-//# sourceMappingURL=graph-schema.js.map

package/dist/handoff.d.ts

@@ -17,4 +17,3 @@ export declare function receiveArtifacts(store: Store, options?: {
     limit?: number;
     verify?: boolean;
 }): ReceivedArtifact[];
-//# sourceMappingURL=handoff.d.ts.map

package/dist/handoff.js

@@ -35,4 +35,3 @@ export function receiveArtifacts(store, options = {}) {
         };
     });
 }
-//# sourceMappingURL=handoff.js.map

package/dist/improvement.d.ts

@@ -29,4 +29,3 @@ export declare function runImprovementCycle(store: Store, runTask: (task: string
     total: number;
     suggestions: StrategySuggestion[];
 }>;
-//# sourceMappingURL=improvement.d.ts.map

package/dist/improvement.js

@@ -64,4 +64,3 @@ export async function runImprovementCycle(store, runTask, evalTasks, applySugges
     }
     return { passed, total, suggestions };
 }
-//# sourceMappingURL=improvement.js.map

package/dist/index.d.ts

@@ -1,11 +1,11 @@
 /**
  * Moltblock — framework for evolving composite intelligences (Entities).
  */
-export declare const VERSION = "0.2.0";
+export declare const VERSION = "0.5.0";
 export type { ModelBinding, BindingEntry, AgentConfig, MoltblockConfig, ChatMessage, VerifiedMemoryEntry, CheckpointEntry, OutcomeEntry, InboxEntry, StrategySuggestion, ReceivedArtifact, GovernanceConfig, } from "./types.js";
 export { WorkingMemory } from "./memory.js";
 export { signArtifact, verifyArtifact, artifactHash } from "./signing.js";
-export { loadMoltblockConfig, defaultCodeEntityBindings, getConfigSource, BindingEntrySchema, AgentConfigSchema, MoltblockConfigSchema, ModelBindingSchema, type ConfigSource, } from "./config.js";
+export { loadMoltblockConfig, defaultCodeEntityBindings, detectProvider, getConfigSource, BindingEntrySchema, AgentConfigSchema, MoltblockConfigSchema, ModelBindingSchema, type BindingOverrides, type ConfigSource, } from "./config.js";
 export { Store, hashGraph, hashMemory, auditLog, getGovernanceValue, setGovernanceValue, putInbox, getInbox, recordOutcome, getRecentOutcomes, getStrategy, setStrategy, } from "./persistence.js";
 export { LLMGateway } from "./gateway.js";
 export { runGenerator, runCritic, runJudge, runRole, } from "./agents.js";
@@ -17,4 +17,3 @@ export { sendArtifact, receiveArtifacts } from "./handoff.js";
 export { critiqueStrategies, applySuggestion, runEval, runImprovementCycle, } from "./improvement.js";
 export { validateTask, validateTestCode, MAX_TASK_LENGTH, MIN_TASK_LENGTH, type ValidationResult, } from "./validation.js";
 export { CodeEntity, loadEntityWithGraph } from "./entity.js";
-//# sourceMappingURL=index.d.ts.map