@nodes/agent 0.0.1 → 0.0.3

package/dist/cli.js

@@ -11,6 +11,7 @@ const { values } = parseArgs({
     options: {
         prompt: { type: 'string', short: 'p' },
         node: { type: 'string', short: 'n' },
+        provider: { type: 'string' },
         serve: { type: 'boolean' },
         simple: { type: 'boolean' },
         help: { type: 'boolean', short: 'h' },
@@ -27,6 +28,7 @@ Usage:
   nodes -n <nodeId>            Resume interactive chat on existing node
   nodes -p "prompt"            Run a single prompt and exit
   nodes -p "prompt" -n <id>    Run prompt in existing chat and exit
+  nodes --provider claude-cli   Use local Claude CLI (Max subscription)
   nodes --serve                Start MCP server (exposes local tools)
   nodes --simple               Use simple readline UI (no TUI)
   nodes --help                 Show this help
@@ -68,8 +70,9 @@ else {
     const userId = tokenMatch?.[1];
     const prompt = values.prompt;
     const nodeId = values.node;
+    const provider = values.provider;
     const nodes = new NodesClient({ url, apiKey, agent });
-    const config = { nodes, agent, userId, prompt, nodeId };
+    const config = { nodes, agent, userId, prompt, nodeId, provider, nodesUrl: url, nodesApiKey: apiKey };
     if (prompt) {
         // One-shot mode
         runOnce(config)

package/dist/core/cli/claude.d.ts

@@ -0,0 +1,2 @@
+import type { CLIStreamOptions } from './shared.js';
+export declare function createClaudeStream(options: CLIStreamOptions): ReadableStream<import("ai").InferUIMessageChunk<import("ai").UIMessage<unknown, import("ai").UIDataTypes, import("ai").UITools>>>;

package/dist/core/cli/claude.js

@@ -0,0 +1,107 @@
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { createUIMessageStream } from 'ai';
+import { waitForExit } from './shared.js';
+export function createClaudeStream(options) {
+    const { prompt, cwd, systemPrompt, mcpConfig, model, sessionId, allowedTools, abortSignal } = options;
+    return createUIMessageStream({
+        async execute({ writer }) {
+            const args = buildArgs({ prompt, systemPrompt, mcpConfig, model, sessionId, allowedTools, bypassPermissions: options.bypassPermissions });
+            const child = spawn('claude', args, {
+                cwd: cwd || process.cwd(),
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            // Log stderr for debugging
+            let stderr = '';
+            child.stderr?.on('data', (chunk) => { stderr += chunk.toString(); });
+            if (abortSignal) {
+                abortSignal.addEventListener('abort', () => child.kill('SIGTERM'), { once: true });
+            }
+            let textPartId = 0;
+            let sessionResult;
+            const rl = createInterface({ input: child.stdout });
+            writer.write({ type: 'start' });
+            writer.write({ type: 'message-metadata', messageMetadata: { provider: options.provider, model: options.model || 'default' } });
+            for await (const line of rl) {
+                let event;
+                try {
+                    event = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                if (event.type === 'assistant') {
+                    for (const block of event.message.content) {
+                        if (block.type === 'text') {
+                            const id = `cli-text-${textPartId++}`;
+                            writer.write({ type: 'text-start', id });
+                            writer.write({ type: 'text-delta', id, delta: block.text });
+                            writer.write({ type: 'text-end', id });
+                        }
+                        else if (block.type === 'tool_use') {
+                            writer.write({ type: 'tool-input-start', toolCallId: block.id, toolName: block.name });
+                            writer.write({ type: 'tool-input-available', toolCallId: block.id, toolName: block.name, input: block.input });
+                        }
+                    }
+                }
+                else if (event.type === 'user') {
+                    const content = event.message.content;
+                    if (Array.isArray(content)) {
+                        for (const block of content) {
+                            if (block.type === 'tool_result') {
+                                writer.write({ type: 'tool-output-available', toolCallId: block.tool_use_id, output: block.content });
+                            }
+                        }
+                    }
+                }
+                else if (event.type === 'result') {
+                    sessionResult = event;
+                }
+            }
+            await waitForExit(child, abortSignal, 'claude').catch(err => {
+                if (stderr)
+                    console.error('[claude] stderr:', stderr);
+                throw err;
+            });
+            if (sessionResult?.usage) {
+                writer.write({ type: 'message-metadata', messageMetadata: {
+                        provider: options.provider,
+                        model: options.model || 'default',
+                        totalUsage: {
+                            inputTokens: sessionResult.usage.input_tokens || 0,
+                            outputTokens: sessionResult.usage.output_tokens || 0,
+                            reasoningTokens: 0,
+                            cachedInputTokens: sessionResult.usage.cache_read_input_tokens || 0,
+                        },
+                        timings: { totalMs: sessionResult.duration_ms || 0 },
+                        costUsd: sessionResult.total_cost_usd,
+                    } });
+            }
+            writer.write({ type: 'finish', finishReason: sessionResult?.subtype === 'success' ? 'stop' : 'error' });
+        },
+    });
+}
+// --- Args ---
+function buildArgs(opts) {
+    const args = ['-p', opts.prompt, '--output-format', 'stream-json', '--verbose'];
+    if (opts.systemPrompt) {
+        args.push('--append-system-prompt', opts.systemPrompt);
+    }
+    if (opts.mcpConfig) {
+        args.push('--mcp-config', JSON.stringify(opts.mcpConfig));
+    }
+    const MODELS = ['opus', 'sonnet', 'haiku'];
+    if (opts.model && MODELS.includes(opts.model)) {
+        args.push('--model', opts.model);
+    }
+    if (opts.sessionId) {
+        args.push('-r', opts.sessionId);
+    }
+    if (opts.allowedTools?.length) {
+        args.push('--allowedTools', opts.allowedTools.join(','));
+    }
+    if (opts.bypassPermissions) {
+        args.push('--dangerously-skip-permissions');
+    }
+    return args;
+}

package/dist/core/cli/codex.d.ts

@@ -0,0 +1,2 @@
+import type { CLIStreamOptions } from './shared.js';
+export declare function createCodexStream(options: CLIStreamOptions): ReadableStream<import("ai").InferUIMessageChunk<import("ai").UIMessage<unknown, import("ai").UIDataTypes, import("ai").UITools>>>;

package/dist/core/cli/codex.js

@@ -0,0 +1,85 @@
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { createUIMessageStream } from 'ai';
+import { waitForExit } from './shared.js';
+export function createCodexStream(options) {
+    const { prompt, cwd, model, abortSignal } = options;
+    return createUIMessageStream({
+        async execute({ writer }) {
+            const args = buildArgs({ prompt, model, systemPrompt: options.systemPrompt, bypassPermissions: options.bypassPermissions });
+            const child = spawn('codex', args, {
+                cwd: cwd || process.cwd(),
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            // Log stderr for debugging
+            let stderr = '';
+            child.stderr?.on('data', (chunk) => { stderr += chunk.toString(); });
+            if (abortSignal) {
+                abortSignal.addEventListener('abort', () => child.kill('SIGTERM'), { once: true });
+            }
+            let textPartId = 0;
+            let turnUsage;
+            const rl = createInterface({ input: child.stdout });
+            writer.write({ type: 'start' });
+            writer.write({ type: 'message-metadata', messageMetadata: { provider: options.provider, model: options.model || 'default' } });
+            for await (const line of rl) {
+                let event;
+                try {
+                    event = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                if (event.type === 'item.completed' && event.item.type === 'agent_message') {
+                    const id = `cli-text-${textPartId++}`;
+                    writer.write({ type: 'text-start', id });
+                    writer.write({ type: 'text-delta', id, delta: event.item.text });
+                    writer.write({ type: 'text-end', id });
+                }
+                else if (event.type === 'item.started' && event.item.type === 'command_execution') {
+                    writer.write({ type: 'tool-input-start', toolCallId: event.item.id, toolName: 'command_execution' });
+                    writer.write({ type: 'tool-input-available', toolCallId: event.item.id, toolName: 'command_execution', input: { command: event.item.command } });
+                }
+                else if (event.type === 'item.completed' && event.item.type === 'command_execution') {
+                    writer.write({ type: 'tool-output-available', toolCallId: event.item.id, output: { output: event.item.aggregated_output, exit_code: event.item.exit_code, status: event.item.status } });
+                }
+                else if (event.type === 'turn.completed') {
+                    turnUsage = event.usage;
+                }
+            }
+            await waitForExit(child, abortSignal, 'codex').catch(err => {
+                console.error('[codex] stderr:', stderr || '(empty)');
+                throw err;
+            });
+            if (turnUsage) {
+                writer.write({ type: 'message-metadata', messageMetadata: {
+                        provider: options.provider,
+                        model: options.model || 'default',
+                        totalUsage: {
+                            inputTokens: turnUsage.input_tokens || 0,
+                            outputTokens: turnUsage.output_tokens || 0,
+                            reasoningTokens: 0,
+                            cachedInputTokens: turnUsage.cached_input_tokens || 0,
+                        },
+                    } });
+            }
+            writer.write({ type: 'finish', finishReason: 'stop' });
+        },
+    });
+}
+// --- Args ---
+function buildArgs(opts) {
+    const args = ['exec', '--json', opts.prompt];
+    // Only pass model if it looks like a valid codex model, skip generic IDs
+    if (opts.model && !opts.model.includes('/')) {
+        args.push('-m', opts.model);
+    }
+    if (opts.systemPrompt) {
+        // Triple-quoted TOML string handles newlines and quotes safely
+        args.push('-c', `instructions="""${opts.systemPrompt}"""`);
+    }
+    if (opts.bypassPermissions) {
+        args.push('--dangerously-bypass-approvals-and-sandbox');
+    }
+    return args;
+}

package/dist/core/cli/gemini.d.ts

@@ -0,0 +1,2 @@
+import type { CLIStreamOptions } from './shared.js';
+export declare function createGeminiStream(options: CLIStreamOptions): ReadableStream<import("ai").InferUIMessageChunk<import("ai").UIMessage<unknown, import("ai").UIDataTypes, import("ai").UITools>>>;

package/dist/core/cli/gemini.js

@@ -0,0 +1,82 @@
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { createUIMessageStream } from 'ai';
+import { waitForExit } from './shared.js';
+export function createGeminiStream(options) {
+    const { prompt, cwd, model, abortSignal } = options;
+    return createUIMessageStream({
+        async execute({ writer }) {
+            const args = buildArgs({ prompt, model, bypassPermissions: options.bypassPermissions });
+            const child = spawn('gemini', args, {
+                cwd: cwd || process.cwd(),
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            if (abortSignal) {
+                abortSignal.addEventListener('abort', () => child.kill('SIGTERM'), { once: true });
+            }
+            let stderr = '';
+            child.stderr?.on('data', (chunk) => { stderr += chunk.toString(); });
+            let textPartId = 0;
+            let resultStats;
+            const rl = createInterface({ input: child.stdout });
+            writer.write({ type: 'start' });
+            writer.write({ type: 'message-metadata', messageMetadata: { provider: options.provider, model: options.model || 'default' } });
+            for await (const line of rl) {
+                let event;
+                try {
+                    event = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                if (event.type === 'message' && event.role === 'assistant') {
+                    const id = `cli-text-${textPartId++}`;
+                    writer.write({ type: 'text-start', id });
+                    writer.write({ type: 'text-delta', id, delta: event.content });
+                    writer.write({ type: 'text-end', id });
+                }
+                else if (event.type === 'tool_use') {
+                    writer.write({ type: 'tool-input-start', toolCallId: event.tool_id, toolName: event.tool_name });
+                    writer.write({ type: 'tool-input-available', toolCallId: event.tool_id, toolName: event.tool_name, input: event.parameters });
+                }
+                else if (event.type === 'tool_result') {
+                    writer.write({ type: 'tool-output-available', toolCallId: event.tool_id, output: event.output });
+                }
+                else if (event.type === 'result') {
+                    resultStats = event.stats;
+                }
+            }
+            await waitForExit(child, abortSignal, 'gemini').catch(err => {
+                if (stderr)
+                    console.error('[gemini] stderr:', stderr);
+                throw err;
+            });
+            if (resultStats) {
+                writer.write({ type: 'message-metadata', messageMetadata: {
+                        provider: options.provider,
+                        model: options.model || 'default',
+                        totalUsage: {
+                            inputTokens: resultStats.input_tokens || 0,
+                            outputTokens: resultStats.output_tokens || 0,
+                            reasoningTokens: 0,
+                            cachedInputTokens: resultStats.cached || 0,
+                        },
+                        timings: { totalMs: resultStats.duration_ms || 0 },
+                    } });
+            }
+            writer.write({ type: 'finish', finishReason: 'stop' });
+        },
+    });
+}
+// --- Args ---
+function buildArgs(opts) {
+    const args = ['-p', opts.prompt, '-o', 'stream-json'];
+    // Skip -m for auto mode (let gemini CLI pick the best model)
+    if (opts.model && !opts.model.includes('/') && !opts.model.startsWith('auto')) {
+        args.push('-m', opts.model);
+    }
+    if (opts.bypassPermissions) {
+        args.push('-y'); // YOLO mode — auto-approve all tool calls
+    }
+    return args;
+}

package/dist/core/cli/shared.d.ts

@@ -0,0 +1,18 @@
+import type { spawn } from 'node:child_process';
+export declare const CLI_PROVIDERS: readonly ["claude-cli", "codex-cli", "gemini-cli"];
+export type CLIProvider = (typeof CLI_PROVIDERS)[number];
+export declare function isCLIProvider(provider: string): provider is CLIProvider;
+export interface CLIStreamOptions {
+    provider: CLIProvider;
+    prompt: string;
+    cwd?: string;
+    systemPrompt?: string;
+    mcpConfig?: Record<string, unknown>;
+    model?: string;
+    sessionId?: string;
+    allowedTools?: string[];
+    /** Skip all permission prompts (for headless/webhook mode) */
+    bypassPermissions?: boolean;
+    abortSignal?: AbortSignal;
+}
+export declare function waitForExit(child: ReturnType<typeof spawn>, abortSignal?: AbortSignal, name?: string): Promise<void>;

package/dist/core/cli/shared.js

@@ -0,0 +1,17 @@
+export const CLI_PROVIDERS = ['claude-cli', 'codex-cli', 'gemini-cli'];
+export function isCLIProvider(provider) {
+    return CLI_PROVIDERS.includes(provider);
+}
+export function waitForExit(child, abortSignal, name = 'cli') {
+    return new Promise((resolve, reject) => {
+        child.on('close', (code) => {
+            if (code !== 0 && !abortSignal?.aborted) {
+                reject(new Error(`${name} exited with code ${code}`));
+            }
+            else {
+                resolve();
+            }
+        });
+        child.on('error', reject);
+    });
+}

package/dist/core/cli-stream.d.ts

@@ -0,0 +1,11 @@
+export { CLI_PROVIDERS, isCLIProvider } from './cli/shared.js';
+export type { CLIProvider, CLIStreamOptions } from './cli/shared.js';
+export { createClaudeStream } from './cli/claude.js';
+export { createCodexStream } from './cli/codex.js';
+export { createGeminiStream } from './cli/gemini.js';
+import type { CLIStreamOptions } from './cli/shared.js';
+/**
+ * Spawns a CLI agent (claude, codex, or gemini) and returns a UIMessageStream
+ * compatible with readUIMessageStream() from Vercel AI SDK.
+ */
+export declare function createCLIStream(options: CLIStreamOptions): ReadableStream<import("ai").InferUIMessageChunk<import("ai").UIMessage<unknown, import("ai").UIDataTypes, import("ai").UITools>>>;

package/dist/core/cli-stream.js

@@ -0,0 +1,21 @@
+// Re-export from per-provider modules
+export { CLI_PROVIDERS, isCLIProvider } from './cli/shared.js';
+export { createClaudeStream } from './cli/claude.js';
+export { createCodexStream } from './cli/codex.js';
+export { createGeminiStream } from './cli/gemini.js';
+import { createClaudeStream } from './cli/claude.js';
+import { createCodexStream } from './cli/codex.js';
+import { createGeminiStream } from './cli/gemini.js';
+/**
+ * Spawns a CLI agent (claude, codex, or gemini) and returns a UIMessageStream
+ * compatible with readUIMessageStream() from Vercel AI SDK.
+ */
+export function createCLIStream(options) {
+    if (options.provider === 'claude-cli')
+        return createClaudeStream(options);
+    if (options.provider === 'codex-cli')
+        return createCodexStream(options);
+    if (options.provider === 'gemini-cli')
+        return createGeminiStream(options);
+    throw new Error(`CLI provider "${options.provider}" not supported.`);
+}

package/dist/core/loop.d.ts

@@ -5,21 +5,30 @@ export interface AgentConfig {
     /** Agent slug (e.g. "nodes/my-agent") or user ID */
     agent: string;
     model?: string;
+    /** Override provider (e.g. "claude-cli" to use local CLI subscription) */
+    provider?: string;
     /** Human user ID — extracted from user-scoped API key (nodes_<userId>_<secret>) */
     userId?: string;
     /** One-shot prompt — run and exit */
     prompt?: string;
     /** Existing chat node ID to resume */
     nodeId?: string;
+    /** Nodes instance URL — needed for CLI providers to build MCP config */
+    nodesUrl?: string;
+    /** Nodes API key — needed for CLI providers to build MCP config */
+    nodesApiKey?: string;
 }
 export interface AgentEnv {
     modelId: string;
-    model: LanguageModel;
+    model?: LanguageModel;
     provider: string;
     allTools: Record<string, any>;
     systemPrompt: string;
     chatsNodeId?: string;
     agentName: string;
+    /** Nodes connection info — used by CLI providers for MCP config */
+    nodesUrl?: string;
+    nodesApiKey?: string;
 }
 export declare function loadAgentEnv(config: AgentConfig): Promise<AgentEnv>;
 export interface TurnOptions {

package/dist/core/loop.js

@@ -2,17 +2,20 @@ import { streamText, hasToolCall, stepCountIs, readUIMessageStream } from 'ai';
 import { localTools } from './tools.js';
 import { loadRemoteTools } from './remote-tools.js';
 import { resolveModel } from './providers.js';
+import { createCLIStream, isCLIProvider } from './cli-stream.js';
 const DEFAULT_MAX_STEPS = 50;
 const MAX_STEPS = Number(process.env.MAX_STEPS) || DEFAULT_MAX_STEPS;
 const stopWhen = [hasToolCall('ai_end'), hasToolCall('ai_buttons'), stepCountIs(MAX_STEPS)];
 export async function loadAgentEnv(config) {
     const { nodes, agent } = config;
     const agentInfo = await nodes.ai.readAgent(agent, { include: ['systemPrompt'] });
-    const provider = agentInfo.ai?.provider || 'gateway';
+    const provider = config.provider || agentInfo.ai?.provider || 'gateway';
     const modelId = config.model || agentInfo.ai?.model || 'google/gemini-2.5-flash';
-    const model = resolveModel(provider, modelId);
-    const remoteTools = await loadRemoteTools(nodes, agentInfo.id);
-    const allTools = { ...localTools, ...remoteTools };
+    // CLI providers use the local CLI binary — no API model needed
+    const model = isCLIProvider(provider) ? undefined : resolveModel(provider, modelId);
+    // CLI providers handle their own tools — skip loading for them
+    const remoteTools = isCLIProvider(provider) ? {} : await loadRemoteTools(nodes, agentInfo.id);
+    const allTools = isCLIProvider(provider) ? {} : { ...localTools, ...remoteTools };
     const systemPrompt = agentInfo.systemPrompt || 'You are a helpful AI agent.';
     return {
         modelId,
@@ -22,10 +25,39 @@ export async function loadAgentEnv(config) {
         systemPrompt,
         chatsNodeId: agentInfo.ai?.chatsNode,
         agentName: agentInfo.name,
+        nodesUrl: config.nodesUrl,
+        nodesApiKey: config.nodesApiKey,
     };
 }
 export async function runTurn(env, options) {
     const startMs = Date.now();
+    // CLI providers: spawn local CLI binary and parse its output
+    if (isCLIProvider(env.provider)) {
+        // For CLI mode, combine message history into a single prompt
+        const prompt = options.messages
+            ? options.messages.map(m => `${m.role}: ${m.content}`).join('\n\n') + '\n\nRespond to the last user message above.'
+            : options.prompt || '';
+        // Build MCP config so Claude CLI can access Nodes platform tools
+        const mcpConfig = (env.nodesUrl && env.nodesApiKey) ? {
+            mcpServers: {
+                nodes: {
+                    type: 'http',
+                    url: `${env.nodesUrl}/api/v1/mcp/`,
+                    headers: { Authorization: `Bearer ${env.nodesApiKey}` },
+                },
+            },
+        } : undefined;
+        const cliStream = createCLIStream({
+            provider: env.provider,
+            prompt,
+            systemPrompt: env.systemPrompt,
+            model: env.modelId,
+            mcpConfig,
+            abortSignal: options.abortSignal,
+        });
+        return consumeUIStream(cliStream, env, options, startMs);
+    }
+    // API providers: use Vercel AI SDK streamText()
     const result = streamText({
         model: env.model,
         system: env.systemPrompt,
@@ -37,7 +69,22 @@ export async function runTurn(env, options) {
             : { prompt: options.prompt || '' }),
     });
     // Use native AI SDK UIMessage stream — same format the Nodes UI uses
-    const uiStream = readUIMessageStream({ stream: result.toUIMessageStream() });
+    const stream = result.toUIMessageStream();
+    const turnResult = await consumeUIStream(stream, env, options, startMs);
+    // API providers have precise usage stats from the SDK
+    const usage = await result.totalUsage;
+    turnResult.metadata.totalUsage = {
+        inputTokens: usage.inputTokens,
+        outputTokens: usage.outputTokens,
+        totalTokens: usage.totalTokens,
+        reasoningTokens: usage.outputTokenDetails?.reasoningTokens,
+        cachedInputTokens: usage.inputTokenDetails?.cacheReadTokens,
+    };
+    return turnResult;
+}
+// --- Shared stream consumer for both API and CLI paths ---
+async function consumeUIStream(stream, env, options, startMs) {
+    const uiStream = readUIMessageStream({ stream });
     let message;
     let prevTextLen = 0;
     let prevReasoningLen = 0;
@@ -79,7 +126,6 @@ export async function runTurn(env, options) {
         }
     }
     const totalMs = Date.now() - startMs;
-    const usage = await result.totalUsage;
     const parts = message?.parts || [];
     const fullText = parts
         .filter(p => p.type === 'text')
@@ -93,13 +139,7 @@ export async function runTurn(env, options) {
         metadata: {
             provider: env.provider,
             model: env.modelId,
-            totalUsage: {
-                inputTokens: usage.inputTokens,
-                outputTokens: usage.outputTokens,
-                totalTokens: usage.totalTokens,
-                reasoningTokens: usage.outputTokenDetails?.reasoningTokens,
-                cachedInputTokens: usage.inputTokenDetails?.cacheReadTokens,
-            },
+            totalUsage: {},
             timings: { totalMs },
         },
     };

package/dist/core/providers.d.ts

@@ -1,2 +1,10 @@
 import type { LanguageModel } from 'ai';
-export declare function resolveModel(provider: string, modelId: string): LanguageModel;
+/**
+ * Resolve a language model from provider + model ID.
+ *
+ * Supports two formats:
+ *   1. Explicit provider: resolveModel('minimax', 'MiniMax-M2.7')
+ *   2. Slash format:      resolveModel('minimax/MiniMax-M2.7')
+ *      (provider extracted from prefix, rest is model ID)
+ */
+export declare function resolveModel(provider: string, modelId?: string): LanguageModel;

package/dist/core/providers.js

@@ -2,7 +2,25 @@ import { createGateway } from '@ai-sdk/gateway';
 import { createOpenAI } from '@ai-sdk/openai';
 import { createAnthropic } from '@ai-sdk/anthropic';
 import { createGoogleGenerativeAI } from '@ai-sdk/google';
+import { createMinimax } from 'vercel-minimax-ai-provider';
+/**
+ * Resolve a language model from provider + model ID.
+ *
+ * Supports two formats:
+ *   1. Explicit provider: resolveModel('minimax', 'MiniMax-M2.7')
+ *   2. Slash format:      resolveModel('minimax/MiniMax-M2.7')
+ *      (provider extracted from prefix, rest is model ID)
+ */
 export function resolveModel(provider, modelId) {
+    // Support "provider/model" format — split on first slash
+    if (!modelId && provider.includes('/')) {
+        const idx = provider.indexOf('/');
+        modelId = provider.slice(idx + 1);
+        provider = provider.slice(0, idx);
+    }
+    if (!modelId) {
+        throw new Error(`No model ID provided for provider "${provider}"`);
+    }
     switch (provider) {
         case 'openai':
             return createOpenAI({ apiKey: process.env.OPENAI_API_KEY }).languageModel(modelId);
@@ -10,8 +28,10 @@ export function resolveModel(provider, modelId) {
             return createAnthropic({ apiKey: process.env.ANTHROPIC_API_KEY }).languageModel(modelId);
         case 'google':
             return createGoogleGenerativeAI({ apiKey: process.env.GOOGLE_API_KEY }).languageModel(modelId);
+        case 'minimax':
+            return createMinimax({ apiKey: process.env.MINIMAX_API_KEY }).languageModel(modelId);
         case 'gateway':
         default:
-            return createGateway({ apiKey: process.env.GATEWAY_API_KEY }).languageModel(modelId);
+            return createGateway({ apiKey: process.env.GATEWAY_API_KEY }).languageModel(modelId.includes('/') ? modelId : `${provider}/${modelId}`);
     }
 }

package/dist/core/serve.js

@@ -4,6 +4,10 @@ import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/
 import { createServer } from 'node:http';
 import { z } from 'zod';
 import { execBash, execReadFile, execWriteFile } from './tools.js';
+import { createCLIStream, isCLIProvider } from './cli-stream.js';
+import { resolveModel } from './providers.js';
+import { localTools } from './tools.js';
+import { JsonToSseTransformStream, readUIMessageStream, streamText, hasToolCall, stepCountIs } from 'ai';
 const require = createRequire(import.meta.url);
 const pkg = require('../../package.json');
 export async function serve(options = {}) {
@@ -94,6 +98,204 @@ export async function serve(options = {}) {
             }
             return;
         }
+        // Chat webhook — receives prompt, spawns CLI, returns SSE stream
+        if (url.pathname === '/chat' && req.method === 'POST') {
+            if (!checkAuth(req)) {
+                console.log(`[chat] ✗ Unauthorized request`);
+                res.writeHead(401, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Unauthorized' }));
+                return;
+            }
+            const chunks = [];
+            for await (const chunk of req)
+                chunks.push(chunk);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            let body;
+            try {
+                body = JSON.parse(Buffer.concat(chunks).toString());
+            }
+            catch {
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Invalid JSON' }));
+                return;
+            }
+            // Build prompt from messages array or direct prompt
+            let prompt = body.prompt;
+            if (!prompt && body.messages?.length) {
+                // Pass full message history as JSON for context preservation
+                prompt = JSON.stringify(body.messages, null, 2);
+            }
+            if (!prompt) {
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Missing prompt or messages' }));
+                return;
+            }
+            const rawProvider = (body.provider || 'claude-cli');
+            const startTime = Date.now();
+            const streamMode = body.stream === false ? 'off' : body.stream === 'raw' ? 'raw' : 'sse';
+            console.log(`[chat] → Received: provider=${rawProvider}, model=${body.model || 'default'}, stream=${streamMode}, prompt=${prompt.length} chars`);
+            // Resolve execution stream — CLI binary or API provider
+            let execStream;
+            if (isCLIProvider(rawProvider)) {
+                // CLI providers: spawn local binary
+                console.log(`[chat]   Spawning CLI stream...`);
+                execStream = createCLIStream({
+                    provider: rawProvider,
+                    prompt,
+                    systemPrompt: body.systemPrompt,
+                    model: body.model,
+                    bypassPermissions: true,
+                });
+            }
+            else {
+                // API providers (including nodes-cli): resolve model from body.model (e.g. "minimax/MiniMax-M2.7")
+                const modelId = body.model || rawProvider;
+                console.log(`[chat]   Resolving API model: ${modelId}`);
+                try {
+                    const model = resolveModel(modelId);
+                    const startAt = Date.now();
+                    let firstTokenAt;
+                    const result = streamText({
+                        model,
+                        system: body.systemPrompt,
+                        tools: localTools,
+                        stopWhen: [hasToolCall('ai_end'), stepCountIs(50)],
+                        ...(body.messages?.length
+                            ? { messages: body.messages }
+                            : { prompt }),
+                    });
+                    // Parse provider/model from the slash format for metadata
+                    const providerName = modelId.includes('/') ? modelId.split('/')[0] : rawProvider;
+                    const modelName = modelId.includes('/') ? modelId.split('/').slice(1).join('/') : modelId;
+                    // Embed real metadata into the stream — same pattern as handlerV2's createMessageMetadata
+                    const messageMetadata = ({ part }) => {
+                        if (!firstTokenAt && part && (part.type === 'text-delta' || part.type === 'reasoning-delta')) {
+                            firstTokenAt = Date.now();
+                            return { timings: { ttfbMs: firstTokenAt - startAt } };
+                        }
+                        if (part.type === 'start') {
+                            return { provider: providerName, model: modelName };
+                        }
+                        if (part.type === 'finish') {
+                            const totalMs = Date.now() - startAt;
+                            const outputPhaseMs = firstTokenAt ? Date.now() - firstTokenAt : undefined;
+                            const usageRaw = (part.totalUsage ?? {});
+                            const outputTokenDetails = usageRaw.outputTokenDetails;
+                            const inputTokenDetails = usageRaw.inputTokenDetails;
+                            const outputTokens = typeof usageRaw.outputTokens === 'number' ? usageRaw.outputTokens : 0;
+                            const reasoningTokens = outputTokenDetails?.reasoningTokens ?? (typeof usageRaw.reasoningTokens === 'number' ? usageRaw.reasoningTokens : 0);
+                            const cachedInputTokens = inputTokenDetails?.cacheReadTokens;
+                            const tokensPerSec = (outputTokens + reasoningTokens) > 0 && outputPhaseMs
+                                ? (outputTokens + reasoningTokens) / (outputPhaseMs / 1000) : undefined;
+                            return {
+                                totalUsage: {
+                                    ...usageRaw,
+                                    reasoningTokens: reasoningTokens || undefined,
+                                    cachedInputTokens: cachedInputTokens || undefined,
+                                },
+                                timings: { ttfbMs: firstTokenAt ? firstTokenAt - startAt : undefined, totalMs, outputPhaseMs, tokensPerSec },
+                            };
+                        }
+                        return undefined;
+                    };
+                    execStream = result.toUIMessageStream({ messageMetadata, sendReasoning: true });
+                }
+                catch (err) {
+                    console.error('[chat] ✗ Model resolution failed:', err);
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: err instanceof Error ? err.message : 'Failed to resolve model' }));
+                    return;
+                }
+            }
+            if (streamMode === 'raw') {
+                // Raw UIMessageStream chunks — for server-to-server (Nodes web)
+                res.writeHead(200, {
+                    'Content-Type': 'application/x-ndjson',
+                    'Cache-Control': 'no-cache',
+                    Connection: 'keep-alive',
+                    'X-Accel-Buffering': 'no',
+                });
+                res.flushHeaders();
+                console.log(`[chat]   Streaming raw...`);
+                let chunkCount = 0;
+                const reader = execStream.getReader();
+                try {
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        chunkCount++;
+                        // Each chunk is a JSON object from the UIMessageStream — write as NDJSON
+                        const line = typeof value === 'string' ? value : JSON.stringify(value);
+                        res.write(line + '\n');
+                    }
+                }
+                catch (err) {
+                    console.error('[chat] ✗ Stream error:', err);
+                }
+                finally {
+                    const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+                    console.log(`[chat] ← Done (raw): ${chunkCount} chunks in ${elapsed}s`);
+                    res.end();
+                }
+            }
+            else if (streamMode === 'sse') {
+                // SSE streaming response — for browsers/external clients
+                const sseStream = execStream.pipeThrough(new JsonToSseTransformStream());
+                res.writeHead(200, {
+                    'Content-Type': 'text/event-stream',
+                    'Cache-Control': 'no-cache',
+                    Connection: 'keep-alive',
+                    'X-Accel-Buffering': 'no',
+                    'X-Vercel-AI-UI-Message-Stream': 'v1',
+                });
+                res.flushHeaders();
+                console.log(`[chat]   Streaming SSE...`);
+                let chunkCount = 0;
+                const reader = sseStream.getReader();
+                try {
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        chunkCount++;
+                        res.write(value);
+                        if (typeof res.flush === 'function') {
+                            res.flush();
+                        }
+                    }
+                }
+                catch (err) {
+                    console.error('[chat] ✗ Stream error:', err);
+                }
+                finally {
+                    const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+                    console.log(`[chat] ← Done (SSE): ${chunkCount} chunks in ${elapsed}s`);
+                    res.end();
+                }
+            }
+            else {
+                // Non-stream: consume stream, return JSON with final UIMessage
+                try {
+                    let lastAssistant;
+                    for await (const snapshot of readUIMessageStream({ stream: execStream })) {
+                        if (snapshot.role === 'assistant')
+                            lastAssistant = snapshot;
+                    }
+                    const message = lastAssistant || { id: 'assistant', role: 'assistant', parts: [] };
+                    const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+                    console.log(`[chat] ← Done (JSON): ${message.parts.length} parts in ${elapsed}s`);
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ message }));
+                }
+                catch (err) {
+                    console.error('[chat] ✗ Error:', err);
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: err instanceof Error ? err.message : 'Execution failed' }));
+                }
+            }
+            return;
+        }
         // Health check
         if (url.pathname === '/health') {
             res.writeHead(200, { 'Content-Type': 'application/json' });
@@ -104,8 +306,10 @@ export async function serve(options = {}) {
         res.end('Not found');
     });
     httpServer.listen(port, () => {
-        console.log(`[serve] Nodes Agent MCP server listening on http://0.0.0.0:${port}/mcp`);
-        console.log(`[serve] Health check: http://localhost:${port}/health`);
+        console.log(`[serve] Nodes Agent server listening on http://0.0.0.0:${port}`);
+        console.log(`[serve] MCP:     http://localhost:${port}/mcp`);
+        console.log(`[serve] Chat:    http://localhost:${port}/chat`);
+        console.log(`[serve] Health:  http://localhost:${port}/health`);
         console.log(`[serve] Tools: bash, read_file, write_file`);
         console.log(`[serve] Auth: ${apiKey ? 'Bearer token required' : 'OPEN (no AGENT_API_KEY set)'}`);
     });

package/package.json

@@ -1,16 +1,32 @@
 {
   "name": "@nodes/agent",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Autonomous AI agent runtime for Nodes",
   "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "src/index.ts",
+  "types": "src/index.ts",
   "bin": {
-    "nodes": "dist/cli.js"
+    "nodes": "src/cli.ts"
+  },
+  "publishConfig": {
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "bin": {
+      "nodes": "dist/cli.js"
+    }
   },
   "files": [
     "dist"
   ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx --env-file=.env src/cli.ts",
+    "prompt": "tsx --env-file=.env src/cli.ts -p",
+    "serve": "tsx --env-file=.env src/cli.ts --serve",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:integration": "vitest run src/tests/run-once.test.ts"
+  },
   "dependencies": {
     "@ai-sdk/anthropic": "3.0.47",
     "@ai-sdk/gateway": "3.0.46",
@@ -18,24 +34,16 @@
     "@ai-sdk/openai": "3.0.33",
     "@mariozechner/pi-tui": "^0.55.0",
     "@modelcontextprotocol/sdk": "1.23.0",
+    "@nodes/sdk": "workspace:*",
     "ai": "6.0.86",
     "picocolors": "^1.1.1",
-    "zod": "3.25.76",
-    "@nodes/sdk": "0.0.1"
+    "vercel-minimax-ai-provider": "0.0.2",
+    "zod": "3.25.76"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",
     "tsx": "^4.19.0",
     "typescript": "^5.6.0",
     "vitest": "^4.0.18"
-  },
-  "scripts": {
-    "build": "tsc",
-    "dev": "tsx --env-file=.env src/cli.ts",
-    "prompt": "tsx --env-file=.env src/cli.ts -p",
-    "serve": "tsx --env-file=.env src/cli.ts --serve",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:integration": "vitest run src/tests/run-once.test.ts"
   }
-}
+}

package/src/cli.ts

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+
+import { parseArgs } from 'node:util'
+import { createRequire } from 'module'
+import { NodesClient } from '@nodes/sdk'
+import { runOnce, interactive } from './core/loop.js'
+import { interactiveTUI } from './core/tui-chat.js'
+import { serve } from './core/serve.js'
+
+const require = createRequire(import.meta.url)
+const pkg = require('../package.json') as { version: string }
+
+const { values } = parseArgs({
+  options: {
+    prompt:   { type: 'string',  short: 'p' },
+    node:     { type: 'string',  short: 'n' },
+    provider: { type: 'string' },
+    serve:    { type: 'boolean' },
+    simple:   { type: 'boolean' },
+    help:     { type: 'boolean', short: 'h' },
+    version:  { type: 'boolean', short: 'v' },
+  },
+  strict: false,
+})
+
+if (values.help) {
+  console.log(`
+nodes — Autonomous AI agent for Nodes
+
+Usage:
+  nodes                        Start in interactive mode (new chat)
+  nodes -n <nodeId>            Resume interactive chat on existing node
+  nodes -p "prompt"            Run a single prompt and exit
+  nodes -p "prompt" -n <id>    Run prompt in existing chat and exit
+  nodes --provider claude-cli   Use local Claude CLI (Max subscription)
+  nodes --serve                Start MCP server (exposes local tools)
+  nodes --simple               Use simple readline UI (no TUI)
+  nodes --help                 Show this help
+
+Environment:
+  NODES_URL              Nodes instance URL (default: https://nodes.ws)
+  NODES_API_KEY          API key for authentication
+  NODES_AGENT            Agent slug (e.g. "nodes/my-agent") or user ID
+  PORT                   MCP server port (default: 8788, --serve only)
+`)
+  process.exit(0)
+}
+
+if (values.version) {
+  console.log(`nodes ${pkg.version}`)
+  process.exit(0)
+}
+
+// --serve doesn't require Nodes credentials (purely local MCP server)
+if (values.serve) {
+  serve().catch((err) => {
+    console.error(err.message)
+    process.exit(1)
+  })
+} else {
+  // All other modes require Nodes connection
+  const url = process.env.NODES_URL || 'https://nodes.ws'
+  const apiKey = process.env.NODES_API_KEY || ''
+  const agent = process.env.NODES_AGENT || ''
+
+  if (!apiKey) {
+    console.error('Error: NODES_API_KEY is required.')
+    process.exit(1)
+  }
+
+  if (!agent) {
+    console.error('Error: NODES_AGENT is required (agent slug or user ID).')
+    process.exit(1)
+  }
+
+  // Extract userId from user-scoped token (nodes_<userId>_<secret>)
+  const tokenMatch = apiKey.match(/^nodes_([a-f0-9]{24})_[a-f0-9]{32}$/)
+  const userId = tokenMatch?.[1]
+
+  const prompt = values.prompt as string | undefined
+  const nodeId = values.node as string | undefined
+  const provider = values.provider as string | undefined
+
+  const nodes = new NodesClient({ url, apiKey, agent })
+  const config = { nodes, agent, userId, prompt, nodeId, provider, nodesUrl: url, nodesApiKey: apiKey }
+
+  if (prompt) {
+    // One-shot mode
+    runOnce(config)
+      .then((result) => {
+        console.log(JSON.stringify(result, null, 2))
+        process.exit(0)
+      })
+      .catch((err) => {
+        console.error(err.message)
+        process.exit(1)
+      })
+      .finally(() => nodes.disconnect())
+  } else {
+    if (values.simple) {
+      // Simple readline mode
+      process.on('SIGINT', async () => {
+        console.log('\nGoodbye.')
+        await nodes.disconnect()
+        process.exit(0)
+      })
+
+      interactive(config).catch((err) => {
+        console.error(err.message)
+        process.exit(1)
+      })
+    } else {
+      // TUI mode (default) — handles its own SIGINT
+      interactiveTUI(config).catch((err) => {
+        console.error(err.message)
+        process.exit(1)
+      })
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export { runOnce, interactive } from './core/loop.js'
+export { localTools } from './core/tools.js'
+export type { AgentConfig } from './core/loop.js'