moltblock 0.4.0 → 0.5.0

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 = {

package/dist/config.d.ts

@@ -48,8 +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>;
+export declare function defaultCodeEntityBindings(overrides?: BindingOverrides): Record<string, ModelBinding>;

package/dist/config.js

@@ -23,6 +23,13 @@ try {
 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'"),
@@ -138,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"]);
@@ -242,23 +280,66 @@ 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);
@@ -271,42 +352,16 @@ export function defaultCodeEntityBindings() {
             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"),
     };
 }

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";

package/dist/index.js

@@ -1,13 +1,13 @@
 /**
  * Moltblock — framework for evolving composite intelligences (Entities).
  */
-export const VERSION = "0.2.0";
+export const VERSION = "0.5.0";
 // Memory
 export { WorkingMemory } from "./memory.js";
 // Signing
 export { signArtifact, verifyArtifact, artifactHash } from "./signing.js";
 // Config
-export { loadMoltblockConfig, defaultCodeEntityBindings, getConfigSource, BindingEntrySchema, AgentConfigSchema, MoltblockConfigSchema, ModelBindingSchema, } from "./config.js";
+export { loadMoltblockConfig, defaultCodeEntityBindings, detectProvider, getConfigSource, BindingEntrySchema, AgentConfigSchema, MoltblockConfigSchema, ModelBindingSchema, } from "./config.js";
 // Persistence
 export { Store, hashGraph, hashMemory, auditLog, getGovernanceValue, setGovernanceValue, putInbox, getInbox, recordOutcome, getRecentOutcomes, getStrategy, setStrategy, } from "./persistence.js";
 // Gateway

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moltblock",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Framework for building evolving composite AI intelligences (Entities)",
   "type": "module",
   "main": "dist/index.js",

package/readme.md

@@ -67,7 +67,7 @@ Blockchain is optional and used only for anchoring.
 
 ## Run (Code Entity MVP)
 
-Requires Node.js 18+, and (for full loop) any OpenAI-compatible API:
+Requires Node.js 22+, and (for full loop) any OpenAI-compatible API:
 - **OpenAI** — `https://api.openai.com/v1` with `OPENAI_API_KEY`
 - **Anthropic Claude** — `https://api.anthropic.com/v1` with `ANTHROPIC_API_KEY`
 - **Google Gemini** — `https://generativelanguage.googleapis.com/v1beta/openai` with `GOOGLE_API_KEY`
@@ -105,6 +105,19 @@ npx moltblock "Implement add(a, b)."
 
 ## Configuration
 
+### Zero-config (auto-detect)
+
+If you have an API key set in your environment, moltblock detects the provider automatically — no config file needed:
+
+```bash
+export OPENAI_API_KEY="sk-..."   # auto-detects OpenAI
+npx moltblock "Implement add(a, b)." --json
+```
+
+Override with CLI flags: `--provider google --model gemini-2.0-flash` or `-p zai -m glm-4.7`.
+
+Detection priority: `OPENAI_API_KEY` > `GOOGLE_API_KEY` > `MOLTBLOCK_ZAI_API_KEY` > localhost.
+
 ### Quick setup
 
 Create a config file at `~/.moltblock/moltblock.json` (user-wide) or `./moltblock.json` (project-specific):