@nodes/agent 0.0.1 → 0.0.2

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/serve.js

@@ -4,6 +4,8 @@ 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 { JsonToSseTransformStream, readUIMessageStream } from 'ai';
 const require = createRequire(import.meta.url);
 const pkg = require('../../package.json');
 export async function serve(options = {}) {
@@ -94,6 +96,113 @@ 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 provider = (body.provider || 'claude-cli');
+            if (!isCLIProvider(provider)) {
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: `Unsupported CLI provider: ${provider}` }));
+                return;
+            }
+            const startTime = Date.now();
+            const shouldStream = body.stream !== false;
+            console.log(`[chat] → Received: provider=${provider}, model=${body.model || 'default'}, stream=${shouldStream}, prompt=${prompt.length} chars`);
+            // Create CLI stream (bypass permissions for headless webhook mode)
+            console.log(`[chat]   Spawning CLI stream...`);
+            const cliStream = createCLIStream({
+                provider: provider,
+                prompt,
+                systemPrompt: body.systemPrompt,
+                model: body.model,
+                bypassPermissions: true,
+            });
+            if (shouldStream) {
+                // SSE streaming response
+                const sseStream = cliStream.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 response...`);
+                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: ${chunkCount} chunks in ${elapsed}s`);
+                    res.end();
+                }
+            }
+            else {
+                // Non-stream: consume CLI stream, return JSON with final UIMessage
+                try {
+                    let lastAssistant;
+                    for await (const snapshot of readUIMessageStream({ stream: cliStream })) {
+                        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 : 'CLI execution failed' }));
+                }
+            }
+            return;
+        }
         // Health check
         if (url.pathname === '/health') {
             res.writeHead(200, { 'Content-Type': 'application/json' });
@@ -104,8 +213,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,6 +1,6 @@
 {
   "name": "@nodes/agent",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Autonomous AI agent runtime for Nodes",
   "type": "module",
   "main": "dist/index.js",