@zhive/cli 0.5.5 → 0.6.0

package/dist/{agent → services/agent/prompts}/prompt.js

@@ -1,3 +1,4 @@
+// ─── Shared Types ─────────────────────────────────
 function humanDuration(ms) {
     const hours = ms / 3_600_000;
     if (hours >= 24) {
@@ -79,32 +80,8 @@ Only skip if this project is outside the expertise list defined in your STRATEGY
 - Major protocol upgrade, big institutional entry, trend reversal → ±6.0 to ±12.0
 - Black swan, regulatory bombshell, massive exploit → ±12.0 to ±25.0
 
-IMPORTANT: Vary your conviction numbers. Do NOT reuse the same number across rounds. Each round has different context — your conviction should reflect that.
-
-## The prediction game
-
-This is a price prediction game for megathread rounds. Each round has a project, a duration, and a round-start baseline price. Your conviction = predicted TOTAL % change from the round-start price by end of the round.
-
-Key inputs for each round:
-- **Round-start price** — your scoring baseline. You predict % change from this.
-- **Current price** — how much has already moved from baseline. Your prediction should account for movement that already happened.
-- **Time remaining** — less time = less room for further movement. Late in the round, anchor your prediction close to where the price already is relative to baseline.
-- **Catalysts & momentum** — news, sentiment shifts, or technical setups that could move price in the remaining window.
-
-Scoring:
-- Correct direction + close to actual = max honey (up to +100)
-- Correct direction but far off = less honey
-- Wrong direction = -25 honey penalty
-- Skipping = no penalty, no reward
-- Earlier predictions earn dramatically more honey (cubic time decay)
-- Predicting late earns almost nothing even if correct
-
-## Using tools
-
-If you have tools available, use them to research current price, OHLC data, technical indicators, mindshare data, and social sentiment. When you use a tool, drop a specific number or fact from the result into your post. Not a data dump, just one concrete detail woven into your take. Examples: "mindshare down 40% this week and nobody cares", "rsi at 28 after that flush", "volume 3x'd overnight". If a tool returns bad data (NaN, null, zero, empty, errors), silently ignore it. Never mention NaN, missing data, "no data", or failed lookups in your post. Just use the tools that gave you something real, or post from instinct if none did.
-
-If your tools return nothing or you have limited data, just run with it. You know crypto. You know this space. Use your general knowledge, recent market conditions, and your trading instincts to form a directional lean. An imperfect prediction beats no prediction. Do NOT mention that you lack data. Never say "no data", "limited data", "couldn't find", "no tools", or anything that reveals you're operating without information. Just post with conviction like you always do. The only exception: if you're deliberately bluffing in character, that's a personality move, not a disclaimer.`;
-    // ── Prompt (dynamic per round — changes every call) ──
+IMPORTANT: Vary your conviction numbers. Do NOT reuse the same number across rounds. Each round has different context — your conviction should reflect that.`;
+    // ── Prompt (dynamic per signal — changes every call) ──
     let recentPostsSection = '';
     if (recentPosts && recentPosts.length > 0) {
         const listed = recentPosts.map((p) => `- "${p}"`).join('\n');
@@ -130,6 +107,7 @@ ${memory}
     const roundStartMs = Math.floor(now / durationMs) * durationMs;
     const timeRemainingMs = Math.max(0, roundStartMs + durationMs - now);
     const timeRemaining = humanDuration(timeRemainingMs);
+    const lateInRound = timeRemainingMs < durationMs * 0.25;
     const nowIso = new Date().toISOString();
     // ── Price context lines ──
     const hasBothPrices = priceAtStart !== undefined && currentPrice !== undefined;
@@ -141,11 +119,33 @@ ${memory}
     }
     let priceContextLines = '';
     if (hasBothPrices) {
-        priceContextLines = `- Round-start price: $${priceAtStart} (scoring baseline)
+        priceContextLines = `- Round-start price: $${priceAtStart} (baseline for scoring)
 - Current price: $${currentPrice} (${currentChangeStr} from round start)`;
     }
     else if (priceAtStart !== undefined) {
-        priceContextLines = `- Round-start price: $${priceAtStart} (scoring baseline)`;
+        priceContextLines = `- Round-start price: $${priceAtStart} (baseline for scoring)`;
+    }
+    // ── What-matters block ──
+    let whatMattersBlock;
+    if (hasBothPrices) {
+        whatMattersBlock = `What matters:
+- **Round-start price** ($${priceAtStart}) — your baseline. Scoring measures % change from here.
+- **Current price** ($${currentPrice}, ${currentChangeStr} from baseline) — price has already moved this much. Your prediction should be close to this unless you expect further movement.
+- **Time remaining** (~${timeRemaining}) — less time = less room for further movement from current price.${lateInRound ? ' Almost no time left — anchor your prediction to the current change (' + currentChangeStr + ').' : ''}
+- **Catalysts & momentum** — news, sentiment shifts, or technical setups that could move price in the remaining window.`;
+    }
+    else if (priceAtStart !== undefined) {
+        whatMattersBlock = `What matters:
+- **Round-start price** ($${priceAtStart}) — your baseline. Scoring measures % change from here.
+- **Current price** — check with tools. Compare to $${priceAtStart} to see how much has already moved.
+- **Time remaining** (~${timeRemaining}) — less time = less room for further movement from current price.${lateInRound ? ' Almost no time left — anchor your prediction to where the price is NOW relative to $' + priceAtStart + '.' : ''}
+- **Catalysts & momentum** — news, sentiment shifts, or technical setups that could move price in the remaining window.`;
+    }
+    else {
+        whatMattersBlock = `What matters:
+- **Current price** — check with tools. This is the most important input to your prediction.
+- **Time remaining** (~${timeRemaining}) — the runway left for price movement. Less time = smaller realistic moves. Scale your conviction accordingly.${lateInRound ? ' Round is almost over — keep your conviction small.' : ''}
+- **Catalysts & momentum** — news, sentiment shifts, or technical setups that could move price in the remaining window.`;
     }
     // ── Scoring & conviction lines ──
     let scoringLine;
@@ -173,11 +173,36 @@ ${memory}
 - Round duration: ${timeframe}
 - Time remaining: ~${timeRemaining}
 ${priceContextLines ? priceContextLines + '\n' : ''}
+## The game
+
+This is a price prediction game. You're predicting the % price change for c/${projectId} over this ${timeframe} round.
+
+${whatMattersBlock}
+
 ## Your task
 
-This is a **megathread round** for c/${projectId}. Form your price conviction for where c/${projectId} will be relative to ${taskBaseline} by end of this ${timeframe} round (~${timeRemaining} left).${thesisHint}
+This is a **megathread round** for c/${projectId}. Form your price conviction for where c/${projectId} will be relative to ${taskBaseline} by end of this ${timeframe} round (~${timeRemaining} left).
+
+**If you have tools available**, use them to research:
+- Check current price, OHLC data, and technical indicators (RSI, MACD, volume, etc.)
+- Look at mindshare data and social sentiment
+- Use any available skills that help you gather market context
+
+**When you use a tool, drop a specific number or fact from the result into your post.** Not a data dump, just one concrete detail woven into your take. Examples: "mindshare down 40% this week and nobody cares", "rsi at 28 after that flush", "volume 3x'd overnight". If a tool returns bad data (NaN, null, zero, empty, errors), silently ignore it. Never mention NaN, missing data, "no data", or failed lookups in your post. Just use the tools that gave you something real, or post from instinct if none did.
+
+**If your tools return nothing or you have limited data**, just run with it. You know crypto. You know this space. Use your general knowledge of c/${projectId}, recent market conditions, and your trading instincts to form a directional lean. An imperfect prediction beats no prediction. Do NOT mention that you lack data, have no data, or couldn't find information. Never say "no data", "limited data", "couldn't find", "no tools", or anything that reveals you're operating without information. Just post with conviction like you always do. The only exception: if you're deliberately bluffing in character — pretending to reference data and then pulling the rug — that's a personality move, not a disclaimer.
+
+Form a thesis based on what you find or what you know.${thesisHint}
+
+## How scoring works
 
 ${scoringLine}
+- Correct direction + close to actual = max honey (up to +100)
+- Correct direction but far off = less honey
+- Wrong direction = -25 honey penalty
+- Skipping = no penalty, no reward
+- Earlier predictions earn dramatically more honey (cubic time decay)
+- Predicting late earns almost nothing even if correct
 ${recentPostsSection}${memorySection}
 Give your take in character and a conviction number.
 ${convictionLine}`;
@@ -276,28 +301,7 @@ Set skip to true and set summary and conviction to null. Real people don't comme
 - Major protocol upgrade, big institutional entry, trend reversal → ±6.0 to ±12.0
 - Black swan, regulatory bombshell, massive exploit → ±12.0 to ±25.0
 
-IMPORTANT: Vary your conviction numbers. Do NOT reuse the same number across signals. Each signal has different strength — your conviction should reflect that.
-
-## The prediction game
-
-This is a price prediction game. Each signal has a snapshot price captured at signal time and a 3-hour evaluation window. Your conviction = predicted % change from the snapshot price by evaluation time.
-
-Key inputs for each signal:
-- **Snapshot price** — your scoring baseline. You predict % change from this.
-- **Current price** — check with tools to see how much has already moved since the signal.
-- **Time left** — less time = less room for further movement. Late in the window, anchor your prediction close to where the price already is relative to the snapshot.
-
-Scoring:
-- Correct direction + close to actual = max honey (up to +100)
-- Correct direction but far off = less honey
-- Wrong direction = -25 honey penalty
-- Skipping = no penalty, no reward
-- Earlier predictions earn dramatically more honey (cubic time decay)
-- Predicting late earns almost nothing even if correct
-
-## Using tools
-
-If you have tools available, use them to check price action, technicals, or mindshare before forming your take. When you use a tool, drop a specific number or fact from the result into your post. Not a data dump, just one concrete detail woven into your take. Examples: "mindshare down 40% this week and nobody cares", "rsi at 28 after that flush", "volume 3x'd overnight". If a tool returns bad data (NaN, null, zero, empty, errors), silently ignore it. Never mention NaN, missing data, "no data", or failed lookups in your post. Just use the tools that gave you something real, or post from instinct if none did.`;
+IMPORTANT: Vary your conviction numbers. Do NOT reuse the same number across signals. Each signal has different strength — your conviction should reflect that.`;
     // ── Prompt (dynamic per signal — changes every call) ──
     let citationsSection = '';
     if (citations.length > 0) {
@@ -334,20 +338,42 @@ ${memory}
     const signalTimeMs = new Date(timestamp).getTime();
     const timeRemainingMs = Math.max(0, signalTimeMs + EVAL_WINDOW_MS - Date.now());
     const timeRemaining = humanDuration(timeRemainingMs);
+    const lateWindow = timeRemainingMs < 45 * 60 * 1000;
     const userPrompt = `## Context
 
 - Project: c/${projectId}
 - Current date: ${currentDate}
 - Signal time: ${timestamp}
-- Snapshot price: $${priceOnFetch} (scoring baseline)
+- Snapshot price: $${priceOnFetch} (captured at signal time)
 - Time left: ~${timeRemaining}
-${citationsSection}${recentPostsSection}${memorySection}
+${citationsSection}
+## The game
+
+This is a price prediction game. Your conviction = predicted % change from the snapshot price ($${priceOnFetch}), evaluated 3 hours after signal time.
+
+What matters:
+- **Snapshot price** ($${priceOnFetch}) — your baseline. Scoring measures % change from here.
+- **Current price** — how much has already moved since the signal. Check with tools.
+- **Time left** (~${timeRemaining}) — less time = less room for further movement from current price.${lateWindow ? ' Almost no time left — anchor your prediction to where the price is NOW relative to the snapshot.' : ''}
+
+## How scoring works
+
+You are predicting the % price change from the snapshot price ($${priceOnFetch}) over 3 hours from signal time.
+- Correct direction + close to actual = max honey (up to +100)
+- Correct direction but far off = less honey
+- Wrong direction = -25 honey penalty
+- Skipping = no penalty, no reward
+- Earlier predictions earn dramatically more honey (cubic time decay)
+- Predicting late earns almost nothing even if correct
+${recentPostsSection}${memorySection}
 Signal/event to react to:
 """
 ${threadText}
 """
 
+**If you have tools available**, use them to check price action, technicals, or mindshare for c/${projectId} before forming your take. When you use a tool, drop a specific number or fact from the result into your post. Not a data dump, just one concrete detail woven into your take. Examples: "mindshare down 40% this week and nobody cares", "rsi at 28 after that flush", "volume 3x'd overnight". If the tool returned nothing useful, ignore it and post from instinct.
+
 Give your take in character and a conviction number.
-Conviction: predicted % price change from $${priceOnFetch} by evaluation time (~${timeRemaining} left), up to one decimal. Positive = up, negative = down.`;
+Conviction: predicted % price change from $${priceOnFetch} by evaluation time (~${timeRemaining} left), up to one decimal. Positive = up, negative = down. 0 = neutral.`;
     return { system, prompt: userPrompt };
 }

package/dist/{agent → services/agent}/tools/market/client.js

@@ -1,4 +1,4 @@
-import { HIVE_API_URL } from '../../../config.js';
+import { HIVE_API_URL } from '../../../config/constant.js';
 /**
  * Client for the backend Market API.
  */

package/dist/{agent → services/agent}/tools/mindshare/client.js

@@ -1,4 +1,4 @@
-import { HIVE_API_URL } from '../../../config.js';
+import { HIVE_API_URL } from '../../../config/constant.js';
 export class MindshareClient {
     constructor(baseUrl = HIVE_API_URL) {
         this._baseUrl = baseUrl;

package/dist/{agents.js → services/config/agent.js}

@@ -2,8 +2,8 @@ import fs from 'fs-extra';
 import path from 'path';
 import os from 'os';
 import axios from 'axios';
-import { AI_PROVIDERS } from './ai-providers.js';
-import { HIVE_API_URL } from './config.js';
+import { AI_PROVIDERS } from '../ai-providers.js';
+import { HIVE_API_URL } from './constant.js';
 function extractField(content, pattern) {
     const match = content.match(pattern);
     if (match === null) {

package/dist/{config.js → services/config/config.js}

@@ -1,12 +1,6 @@
 import fs from 'fs-extra';
 import path from 'path';
-import os from 'os';
-export const HIVE_API_URL = 'https://api.zhive.ai';
-export const HIVE_FRONTEND_URL = 'https://www.zhive.ai';
-export function getHiveDir() {
-    const hiveDir = path.join(os.homedir(), '.hive');
-    return hiveDir;
-}
+import { getHiveDir } from './constant.js';
 export async function readConfig() {
     try {
         const configPath = path.join(getHiveDir(), 'config.json');

package/dist/services/config/constant.js

@@ -0,0 +1,8 @@
+import path from 'path';
+import os from 'os';
+export const HIVE_API_URL = 'https://api.zhive.ai';
+export const HIVE_FRONTEND_URL = 'https://www.zhive.ai';
+export function getHiveDir() {
+    const hiveDir = path.join(os.homedir(), '.hive');
+    return hiveDir;
+}

package/dist/shared/agent/config.js

@@ -0,0 +1,75 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+async function loadMarkdownFile(filename) {
+    const filePath = path.join(process.cwd(), filename);
+    const content = await fs.readFile(filePath, 'utf-8');
+    return content;
+}
+function extractField(content, pattern) {
+    const match = content.match(pattern);
+    if (match === null) {
+        return null;
+    }
+    const value = match[1].trim();
+    return value;
+}
+const VALID_SENTIMENTS = [
+    'very-bullish',
+    'bullish',
+    'neutral',
+    'bearish',
+    'very-bearish',
+];
+const VALID_TIMEFRAMES = ['1h', '4h', '24h'];
+function parseSentiment(raw) {
+    if (raw !== null && VALID_SENTIMENTS.includes(raw)) {
+        return raw;
+    }
+    return 'neutral';
+}
+function parseSectors(raw) {
+    if (raw === null || raw.trim() === '') {
+        return [];
+    }
+    const sectors = raw
+        .split(',')
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+    return sectors;
+}
+function parseTimeframes(raw) {
+    if (raw === null || raw.trim() === '') {
+        return ['1h', '4h', '24h'];
+    }
+    const parsed = raw
+        .split(',')
+        .map((t) => t.trim())
+        .filter((t) => VALID_TIMEFRAMES.includes(t));
+    if (parsed.length === 0) {
+        return ['1h', '4h', '24h'];
+    }
+    return parsed;
+}
+export async function loadAgentConfig() {
+    const soulContent = await loadMarkdownFile('SOUL.md');
+    const strategyContent = await loadMarkdownFile('STRATEGY.md');
+    const name = extractField(soulContent, /^#\s+Agent:\s+(.+)$/m);
+    if (name === null) {
+        throw new Error('Could not parse agent name from SOUL.md. Expected "# Agent: <name>" as the first heading.');
+    }
+    const avatarUrl = extractField(soulContent, /^## Avatar\s*\n+(https?:\/\/.+)$/m);
+    if (avatarUrl === null) {
+        throw new Error('Could not parse avatar URL from SOUL.md. Expected a valid URL under "## Avatar".');
+    }
+    const bioRaw = extractField(soulContent, /^## Bio\s*\n+(.+)$/m);
+    const bio = bioRaw ?? null;
+    const sentimentRaw = extractField(strategyContent, /^-\s+Bias:\s+(.+)$/m);
+    const sectorsRaw = extractField(strategyContent, /^-\s+Sectors:\s+(.+)$/m);
+    const timeframesRaw = extractField(strategyContent, /^-\s+Active timeframes:\s+(.+)$/m);
+    const agentProfile = {
+        sentiment: parseSentiment(sentimentRaw),
+        sectors: parseSectors(sectorsRaw),
+        timeframes: parseTimeframes(timeframesRaw),
+    };
+    return { name, bio, avatarUrl, soulContent, strategyContent, agentProfile };
+}

package/dist/shared/agent/env.js

@@ -0,0 +1,30 @@
+import { readFileSync } from 'fs';
+import { AI_PROVIDER_ENV_VARS } from '../ai-providers.js';
+let _agentProviderKeys = new Set();
+/**
+ * Provider env-var names declared in the agent's .env file.
+ * Used by getModel() to prioritize the agent's chosen provider
+ * over keys inherited from the shell.
+ */
+export function getAgentProviderKeys() {
+    return _agentProviderKeys;
+}
+/**
+ * Load the agent's .env with provider-key priority.
+ *
+ * 1. Parse .env to discover which provider keys the agent declared.
+ * 2. Load .env with override so the agent's values win for the same key.
+ * 3. getModel() uses getAgentProviderKeys() to check those providers first,
+ *    falling back to shell-inherited keys if the agent has none.
+ */
+export async function loadAgentEnv() {
+    try {
+        const content = readFileSync('.env', 'utf-8');
+        _agentProviderKeys = new Set(AI_PROVIDER_ENV_VARS.filter((key) => new RegExp(`^${key}=`, 'm').test(content)));
+    }
+    catch {
+        _agentProviderKeys = new Set();
+    }
+    const { config } = await import('dotenv');
+    config({ override: true });
+}

package/dist/shared/agent/handler.js

@@ -0,0 +1,129 @@
+import { processMegathreadRound, screenMegathreadRound, } from './analysis.js';
+import { getMarketClient } from './tools/market/index.js';
+import { extractErrorMessage } from './utils.js';
+export const fetchPrice = async (projectId, timestamp) => {
+    const client = getMarketClient();
+    const response = await client.getPrice(projectId, timestamp);
+    return response.price ?? undefined;
+};
+export async function fetchRoundPrices(projectId, roundTimestamp, currentTime) {
+    let priceAtStart;
+    let currentPrice;
+    try {
+        const client = getMarketClient();
+        [priceAtStart, currentPrice] = await Promise.all([
+            fetchPrice(projectId, roundTimestamp),
+            fetchPrice(projectId, currentTime ?? new Date().toISOString()),
+        ]);
+    }
+    catch {
+        // Price fetch failed — both stay undefined
+    }
+    return {
+        priceAtStart,
+        currentPrice,
+    };
+}
+const calculateTimeframe = (round) => {
+    const hours = Math.round(round.durationMs / 3_600_000);
+    const timeframe = hours >= 1 ? `${hours}h` : `${Math.round(round.durationMs / 60_000)}m`;
+    return timeframe;
+};
+async function run({ round, runtime, reporter, recentComments, }) {
+    const timeframe = calculateTimeframe(round);
+    reporter.onRoundStart(round, timeframe);
+    // ── Fetch prices ──────────────────────────────
+    const roundStartTimestamp = round.roundId.split('@Z')[0];
+    const { priceAtStart, currentPrice } = await fetchRoundPrices(round.projectId, roundStartTimestamp);
+    if (priceAtStart !== undefined) {
+        reporter.onPriceInfo(priceAtStart, currentPrice);
+    }
+    // ── Quick screen (cheap engage check) ───────
+    const screenResult = await screenMegathreadRound(round.projectId, runtime.config.strategyContent);
+    if (!screenResult.engage) {
+        reporter.onScreenResult?.(round, screenResult);
+        return { skip: true, usage: screenResult.usage, screenResult };
+    }
+    reporter.onResearching(round.projectId);
+    // ── Run analysis ──────────────────────────────
+    const result = await processMegathreadRound({
+        projectId: round.projectId,
+        durationMs: round.durationMs,
+        recentComments,
+        agentRuntime: runtime,
+        priceAtStart,
+        currentPrice,
+    });
+    reporter.onToolsUsed(result.usage.toolNames, result.usage.toolCalls);
+    if (result.skip) {
+        reporter.onSkipped(round, result.usage);
+    }
+    return result;
+}
+export function createMegathreadRoundBatchHandler(getAgent, runtime, reporter) {
+    const handler = async (rounds) => {
+        const agent = getAgent();
+        const promises = [];
+        // report item in order that it is polled to prevent out-of-order write to stdout
+        for (const round of rounds) {
+            promises.push(run({ round, runtime, reporter, recentComments: agent.recentComments }));
+        }
+        const results = await Promise.allSettled(promises);
+        for (let i = 0; i < results.length; i++) {
+            const round = rounds[i];
+            const result = results[i];
+            if (result.status === 'rejected') {
+                const raw = extractErrorMessage(result.reason);
+                const message = raw.length > 120 ? raw.slice(0, 120) + '\u2026' : raw;
+                reporter.onError(round, message);
+                continue;
+            }
+            const data = result.value;
+            if (data.skip) {
+                continue;
+            }
+            // TODO: we can optimized this by create method to commit this in batch in hive sdk.
+            // postMegathreadComment cannot be run concurrently so we need to call it one by one.
+            await agent.postMegathreadComment(round.roundId, {
+                text: data.summary,
+                conviction: data.conviction,
+                tokenId: round.projectId,
+                roundDuration: round.durationMs,
+            });
+            const timeframe = calculateTimeframe(round);
+            reporter.onPosted(round, data.conviction, data.summary, timeframe, data.usage);
+        }
+    };
+    return handler;
+}
+export function createMegathreadRoundHandler(getAgent, runtime, reporter) {
+    const handler = async (round) => {
+        const agent = getAgent();
+        try {
+            const result = await run({
+                round,
+                reporter,
+                recentComments: agent.recentComments,
+                runtime,
+            });
+            if (result.skip) {
+                return;
+            }
+            // ── Post comment ──────────────────────────────
+            await agent.postMegathreadComment(round.roundId, {
+                text: result.summary,
+                conviction: result.conviction,
+                tokenId: round.projectId,
+                roundDuration: round.durationMs,
+            });
+            const timeframe = calculateTimeframe(round);
+            reporter.onPosted(round, result.conviction, result.summary, timeframe, result.usage);
+        }
+        catch (err) {
+            const raw = extractErrorMessage(err);
+            const message = raw.length > 120 ? raw.slice(0, 120) + '\u2026' : raw;
+            reporter.onError(round, message);
+        }
+    };
+    return handler;
+}

package/dist/shared/agent/helpers/model.js

@@ -0,0 +1,92 @@
+import { AI_PROVIDERS } from '../../ai-providers.js';
+import { getAgentProviderKeys } from '../../config/env-loader.js';
+const PROVIDERS = [
+    {
+        label: 'Anthropic',
+        envVar: 'ANTHROPIC_API_KEY',
+        load: async (modelId) => {
+            const { anthropic } = await import('@ai-sdk/anthropic');
+            return anthropic(modelId);
+        },
+    },
+    {
+        label: 'OpenAI',
+        envVar: 'OPENAI_API_KEY',
+        load: async (modelId) => {
+            const { openai } = await import('@ai-sdk/openai');
+            return openai(modelId);
+        },
+    },
+    {
+        label: 'Google',
+        envVar: 'GOOGLE_GENERATIVE_AI_API_KEY',
+        load: async (modelId) => {
+            const { google } = await import('@ai-sdk/google');
+            return google(modelId);
+        },
+    },
+    {
+        label: 'xAI',
+        envVar: 'XAI_API_KEY',
+        load: async (modelId) => {
+            const { xai } = await import('@ai-sdk/xai');
+            return xai(modelId);
+        },
+    },
+    {
+        label: 'OpenRouter',
+        envVar: 'OPENROUTER_API_KEY',
+        load: async (modelId) => {
+            const { createOpenRouter } = await import('@openrouter/ai-sdk-provider');
+            const openrouter = createOpenRouter({ apiKey: process.env.OPENROUTER_API_KEY });
+            return openrouter.chat(modelId);
+        },
+    },
+];
+export function resolveModelInfo() {
+    const overrideModel = process.env.HIVE_MODEL;
+    const agentKeys = getAgentProviderKeys();
+    const sortedProviders = [
+        ...PROVIDERS.filter((p) => agentKeys.has(p.envVar)),
+        ...PROVIDERS.filter((p) => !agentKeys.has(p.envVar)),
+    ];
+    for (const provider of sortedProviders) {
+        const keyValue = process.env[provider.envVar];
+        if (keyValue && keyValue.trim().length > 0) {
+            const centralProvider = AI_PROVIDERS.find((p) => p.envVar === provider.envVar);
+            const runtimeModel = centralProvider?.models.runtime ?? 'unknown';
+            const modelId = overrideModel ?? runtimeModel;
+            const source = agentKeys.has(provider.envVar) ? '.env' : 'shell';
+            return { provider: provider.label, modelId, source };
+        }
+    }
+    return { provider: 'unknown', modelId: 'unknown', source: 'unknown' };
+}
+let _modelPromise = null;
+export function getModel() {
+    if (_modelPromise) {
+        return _modelPromise;
+    }
+    _modelPromise = (async () => {
+        const info = resolveModelInfo();
+        if (info.provider === 'unknown') {
+            throw new Error('No AI provider API key found in environment. ' +
+                'Set one of: ANTHROPIC_API_KEY, OPENAI_API_KEY, GOOGLE_GENERATIVE_AI_API_KEY, XAI_API_KEY, OPENROUTER_API_KEY');
+        }
+        const agentKeys = getAgentProviderKeys();
+        const sortedProviders = [
+            ...PROVIDERS.filter((p) => agentKeys.has(p.envVar)),
+            ...PROVIDERS.filter((p) => !agentKeys.has(p.envVar)),
+        ];
+        for (const provider of sortedProviders) {
+            const keyValue = process.env[provider.envVar];
+            if (keyValue && keyValue.trim().length > 0) {
+                const modelId = info.modelId;
+                const model = await provider.load(modelId);
+                return model;
+            }
+        }
+        throw new Error('Unreachable: resolveModelInfo succeeded but no provider found');
+    })();
+    return _modelPromise;
+}

package/dist/shared/agent/runtime.js

@@ -0,0 +1,15 @@
+import { loadAgentConfig } from '../config/agent.js';
+import { loadMemory } from '@zhive/sdk';
+import { getModel } from '../config/ai-providers.js';
+import { getAllTools, getExecuteSkillTool, initializeSkills } from './tools/index.js';
+export async function initializeAgentRuntime(agentDir) {
+    const config = await loadAgentConfig(agentDir);
+    const memory = await loadMemory(agentDir);
+    const model = await getModel();
+    const skillRegistry = await initializeSkills(agentDir);
+    const tools = getAllTools();
+    const executeSkillTool = getExecuteSkillTool(skillRegistry, model);
+    const allTools = { ...tools, executeSkillTool };
+    const runtime = { config, memory, tools: allTools, skills: skillRegistry, model };
+    return runtime;
+}

package/dist/shared/ai-providers.js

@@ -0,0 +1,66 @@
+export const AI_PROVIDERS = [
+    {
+        id: 'openai',
+        label: 'OpenAI',
+        package: '@ai-sdk/openai',
+        envVar: 'OPENAI_API_KEY',
+        models: { validation: 'gpt-4o-mini', generation: 'gpt-5-mini', runtime: 'gpt-5-mini' },
+    },
+    {
+        id: 'anthropic',
+        label: 'Anthropic',
+        package: '@ai-sdk/anthropic',
+        envVar: 'ANTHROPIC_API_KEY',
+        models: {
+            validation: 'claude-haiku-4-5-20251001',
+            generation: 'claude-haiku-4-5',
+            runtime: 'claude-haiku-4-5',
+        },
+    },
+    {
+        id: 'google',
+        label: 'Google',
+        package: '@ai-sdk/google',
+        envVar: 'GOOGLE_GENERATIVE_AI_API_KEY',
+        models: {
+            validation: 'gemini-2.0-flash',
+            generation: 'gemini-3-flash-preview',
+            runtime: 'gemini-3-flash-preview',
+        },
+    },
+    {
+        id: 'xai',
+        label: 'xAI',
+        package: '@ai-sdk/xai',
+        envVar: 'XAI_API_KEY',
+        models: {
+            validation: 'grok-2',
+            generation: 'grok-4-1-fast-reasoning',
+            runtime: 'grok-4-1-fast-reasoning',
+        },
+    },
+    {
+        id: 'openrouter',
+        label: 'OpenRouter',
+        package: '@openrouter/ai-sdk-provider',
+        envVar: 'OPENROUTER_API_KEY',
+        models: {
+            validation: 'openai/gpt-4o-mini',
+            generation: 'openai/gpt-5.1-mini',
+            runtime: 'openai/gpt-5.1-mini',
+        },
+    },
+];
+/**
+ * All env-var names used by AI providers.
+ * Used to clear shell-inherited keys before loading an agent's .env,
+ * so only the agent's chosen provider is active.
+ */
+export const AI_PROVIDER_ENV_VARS = AI_PROVIDERS.map((p) => p.envVar);
+export function getProvider(id) {
+    const provider = AI_PROVIDERS.find((p) => p.id === id);
+    if (!provider) {
+        throw new Error(`Unknown AI provider: ${id}`);
+    }
+    return provider;
+}