@nodes/agent 0.0.2 → 0.0.3

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

@@ -5,7 +5,9 @@ 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';
+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 = {}) {
@@ -128,27 +130,118 @@ export async function serve(options = {}) {
                 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 rawProvider = (body.provider || 'claude-cli');
             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());
+            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',
@@ -157,7 +250,7 @@ export async function serve(options = {}) {
                     'X-Vercel-AI-UI-Message-Stream': 'v1',
                 });
                 res.flushHeaders();
-                console.log(`[chat]   Streaming response...`);
+                console.log(`[chat]   Streaming SSE...`);
                 let chunkCount = 0;
                 const reader = sseStream.getReader();
                 try {
@@ -177,15 +270,15 @@ export async function serve(options = {}) {
                 }
                 finally {
                     const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
-                    console.log(`[chat] ← Done: ${chunkCount} chunks in ${elapsed}s`);
+                    console.log(`[chat] ← Done (SSE): ${chunkCount} chunks in ${elapsed}s`);
                     res.end();
                 }
             }
             else {
-                // Non-stream: consume CLI stream, return JSON with final UIMessage
+                // Non-stream: consume stream, return JSON with final UIMessage
                 try {
                     let lastAssistant;
-                    for await (const snapshot of readUIMessageStream({ stream: cliStream })) {
+                    for await (const snapshot of readUIMessageStream({ stream: execStream })) {
                         if (snapshot.role === 'assistant')
                             lastAssistant = snapshot;
                     }
@@ -198,7 +291,7 @@ export async function serve(options = {}) {
                 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' }));
+                    res.end(JSON.stringify({ error: err instanceof Error ? err.message : 'Execution failed' }));
                 }
             }
             return;

package/package.json

@@ -1,16 +1,32 @@
 {
   "name": "@nodes/agent",
-  "version": "0.0.2",
+  "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'