@nodes/agent 0.0.2 → 0.0.4

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,6 +1,6 @@
 {
   "name": "@nodes/agent",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "Autonomous AI agent runtime for Nodes",
   "type": "module",
   "main": "dist/index.js",
@@ -20,6 +20,7 @@
     "@modelcontextprotocol/sdk": "1.23.0",
     "ai": "6.0.86",
     "picocolors": "^1.1.1",
+    "vercel-minimax-ai-provider": "0.0.2",
     "zod": "3.25.76",
     "@nodes/sdk": "0.0.1"
   },