@nodetool-ai/websocket 0.8.2 → 0.8.4-a24.1

package/dist/session/chat-turn.js

@@ -1,6 +1,6 @@
 import { registerChatRunTrace, registerWorkflowRunTrace, withRegisteredRunTrace, settleRegisteredRunTrace } from "@nodetool-ai/execution";
 import { getRunTraceScope, suppressRunTraceContent } from "@nodetool-ai/runtime";
-import { TRACE_RESTRICTED_CAPABILITY_MODULES } from "@nodetool-ai/protocol";
+import { TRACE_RESTRICTED_CAPABILITY_MODULES, missingPackDetailsOf, isFullResourceId } from "@nodetool-ai/protocol";
 import { trace, SpanStatusCode } from "@opentelemetry/api";
 import { settleRunTrace, registerRunTraceParent, registerRunTraceParents, threadHasTraceContentTools } from "@nodetool-ai/models";
 import { capabilityModuleOf, listCapabilitySpecs } from "@nodetool-ai/agents";
@@ -8,6 +8,8 @@ import { createLogger } from "@nodetool-ai/config";
 import { randomUUID } from "node:crypto";
 import { SUPERSEDED_TOOL_RESULT, repairOrphanedToolCalls } from "../chat-tool-call-repair.js";
 import { attachChatPredictionForwarder } from "../chat-prediction-forwarder.js";
+import { dispatchClientTool } from "./client-tool-gate.js";
+import { admitSpend } from "../credit-gate.js";
 import { isGoogleWorkspaceEnabled } from "@nodetool-ai/config";
 import { isFunctionValue, isNonEmptyString, isNumber, isObjectLike, isRecord, isString } from "../lib/wire-values.js";
 import { storeAssetWithThumbnail } from "../lib/thumbnail.js";
@@ -16,7 +18,7 @@ import { attachRunCostLedger, linkGenerationAssets, ExecutionSession, isExecutio
 import { Asset, COMPACTION_EVENT_TYPE, compactionMessageContent, isCompactionMessage, Job, Message, Prediction, Project, Skill, Thread, Memory, Workflow } from "@nodetool-ai/models";
 import { WORKFLOW_DOCUMENT_TOOL_NAMES } from "@nodetool-ai/node-sdk";
 import { ACTIVE_MODEL_CONTEXT_KEY, DIRECT_TOOL_NAMES, RUN_BUDGET_CONTEXT_KEY, createRunBudget, detectImageMime, IMAGE_MIME_TO_EXT, expandEntitiesForGeneration, getProcessSandboxModuleCatalog, estimatePromptTokens, isToolCall, isProviderSessionUpdate, isProviderMessageEvent, isProviderStop, httpStatusFromError, groqRequestFailureMessage, mediaResolverFor, providerFailureDetail, resolveContextWindow } from "@nodetool-ai/runtime";
-import { isModelSelection, PROVIDER_IDS, NO_MODEL_SELECTED_MESSAGE, noMediaModelSelectedMessage } from "@nodetool-ai/protocol";
+import { isModelSelection, isReasoningEffort, supportsReasoningEffort, PROVIDER_IDS, NO_MODEL_SELECTED_MESSAGE, noMediaModelSelectedMessage } from "@nodetool-ai/protocol";
 import { Tool, compactAssetUris, compactResourceIds } from "@nodetool-ai/agents";
 import { createChatCodeActSession, createSandboxClock, sandboxPackagesForChat, CODEACT_RESIDENT_TOOL_NAMES, EXECUTE_CODE_TOOL_NAME } from "@nodetool-ai/agents";
 import { availableBuiltinToolNames, GOOGLE_WORKSPACE_TOOL_NAMES, APIFY_TOOL_NAMES, SERPAPI_TOOL_NAMES, capabilityForName, capabilityProviderTool, getAllMcpCapabilitySpecs, toolFromCapability, capabilityFromTool, createCapabilityRun, contextSecretAvailability, BackgroundSubtaskRegistry, PERMISSION_GATE_CONTEXT_KEY, GAME_ASSET_NODE_RUNNER_CONTEXT_KEY, extractInjectableImages, registerTemporaryImageHandle } from "@nodetool-ai/agents";
@@ -248,6 +250,27 @@ const MEMORY_BLOCK_LIMIT = 100;
  * full thread load.
  */
 const SESSION_PROBE_WINDOW = 50;
+/** The most rows of a thread a turn loads as its history. */
+const THREAD_HISTORY_LIMIT = 1000;
+/**
+ * The thread's newest rows, oldest first. An ascending page would return the
+ * oldest rows instead, and a thread past the limit would then lose its latest
+ * turns, the user message just sent among them.
+ *
+ * A window cut by the limit starts at its first user row, so it never opens on
+ * a tool result whose call fell outside it.
+ */
+export async function loadRecentThreadRows(threadId, limit = THREAD_HISTORY_LIMIT) {
+    const [newestFirst] = await Message.paginate(threadId, {
+        reverse: true,
+        limit
+    });
+    const rows = newestFirst.reverse();
+    if (rows.length < limit)
+        return rows;
+    const firstUser = rows.findIndex((row) => row.role === "user");
+    return firstUser > 0 ? rows.slice(firstUser) : rows;
+}
 /**
  * Output-token worst case assumed when reserving a chat turn. The chat loop
  * sends no `maxTokens`, so nothing bounds the answer from this side; the
@@ -505,6 +528,12 @@ export class ChatTurnHandler {
         const existing = await Thread.find(userId, threadId);
         if (existing)
             return existing.id;
+        // `create` upserts on the primary key, so creating under an id another
+        // user's thread already holds would reassign that thread (and its
+        // history) to this caller.
+        if (await Thread.get(threadId)) {
+            throw new Error("Thread not found");
+        }
         const thread = await Thread.create({
             id: threadId,
             user_id: userId,
@@ -518,14 +547,24 @@ export class ChatTurnHandler {
      * Save a message dict to the database.
      * Mirrors Python's _save_message_to_db_async: pops id, type, user_id before create.
      */
-    async saveMessageToDb(messageData) {
+    async saveMessageToDb(messageData, options = {}) {
         const data = { ...messageData };
+        const clientId = data.id;
         delete data.id;
         delete data.type;
         const threadId = isString(data.thread_id) ? data.thread_id : "";
         delete data.thread_id;
         const userId = this.session.requireUserId();
         delete data.user_id;
+        // The user's own turn keeps the id the client minted for it, so the client
+        // can name that turn later (Regenerate, edit a sent message) without a
+        // round-trip. Anything that is not a fresh 32-hex id is replaced.
+        if (options.keepClientId &&
+            isString(clientId) &&
+            isFullResourceId(clientId) &&
+            !(await Message.find(clientId))) {
+            data.id = clientId;
+        }
         const message = await Message.create({ thread_id: threadId, user_id: userId, ...data });
         const scope = getRunTraceScope();
         if (scope) {
@@ -939,6 +978,10 @@ export class ChatTurnHandler {
             graph = await this.deps.hydrateGraph(rawGraph);
         }
         catch (err) {
+            const missing = missingPackDetailsOf(err);
+            if (missing) {
+                return missing;
+            }
             return {
                 error: `Failed to prepare node '${nodeType}': ${err instanceof Error ? err.message : String(err)}`
             };
@@ -948,6 +991,10 @@ export class ChatTurnHandler {
                 await this.deps.beforeRunJob(graph);
             }
             catch (err) {
+                const missing = missingPackDetailsOf(err);
+                if (missing) {
+                    return missing;
+                }
                 return {
                     error: `Node prerequisites failed: ${err instanceof Error ? err.message : String(err)}`
                 };
@@ -997,6 +1044,10 @@ export class ChatTurnHandler {
             });
         }
         catch (err) {
+            const missing = missingPackDetailsOf(err);
+            if (missing) {
+                return missing;
+            }
             if (!isExecutionPreflightError(err))
                 throw err;
             return { error: err.message };
@@ -1015,6 +1066,9 @@ export class ChatTurnHandler {
             }
         }
         if (result.status === "failed") {
+            if (result.missingPack) {
+                return result.missingPack;
+            }
             return { error: result.error ?? `Node '${nodeType}' failed` };
         }
         if (nodeResult === undefined) {
@@ -1083,7 +1137,7 @@ export class ChatTurnHandler {
         const userId = this.session.requireUserId();
         log.debug("Chat message", { threadId, model, provider: providerId });
         // Save user message to DB — matches Python's _save_message_to_db_async(data)
-        const turnMessage = await this.saveMessageToDb(data);
+        const turnMessage = await this.saveMessageToDb(data, { keepClientId: true });
         const rootContext = createRuntimeContext({ jobId: turnMessage.id, threadId, workflowId, userId, workspace: null });
         await registerChatRunTrace(rootContext, { messageId: turnMessage.id, threadId });
         return withRegisteredRunTrace(rootContext, "chat.turn", async () => {
@@ -1117,6 +1171,21 @@ export class ChatTurnHandler {
             });
             return;
         }
+        // The managed provider spends NodeTool's own keys against the user's
+        // credits. Every other managed entry point admits against the balance and
+        // the operator's model whitelist first, and so does a chat turn.
+        if (providerId === "nodetool") {
+            const decision = await admitSpend(userId, 0, [model]);
+            if (!decision.allowed) {
+                await settleRegisteredRunTrace(rootContext, "failed", decision.reason);
+                await this.session.send({
+                    type: "error",
+                    message: decision.reason,
+                    thread_id: threadId
+                });
+                return;
+            }
+        }
         // Route to the workflow processor ONLY when the client explicitly opts in
         // via `workflow_target: "workflow"`. A bare `workflow_id` is context, not a
         // routing signal: the editor binds the open workflow so `ui_*` tools target
@@ -1127,7 +1196,7 @@ export class ChatTurnHandler {
             ? data.workflow_target
             : null;
         if (workflowTarget === "workflow") {
-            await this.handleWorkflowMessage(data, requestSeq, signal);
+            await this.handleWorkflowMessage(data, turnMessage.id, requestSeq, signal);
             return;
         }
         // Route to media generation when the client requests a text-to-image or
@@ -1152,6 +1221,12 @@ export class ChatTurnHandler {
             data.permission_mode === "default"
             ? data.permission_mode
             : "default";
+        // The composer's reasoning level. Only models that accept it receive it,
+        // so a stale pick from another model is dropped rather than sent.
+        const reasoningEffort = isReasoningEffort(data.reasoning_effort) &&
+            supportsReasoningEffort(providerId, model)
+            ? data.reasoning_effort
+            : undefined;
         // A surface can send a context-specific system-prompt addendum (e.g. the
         // App Builder's build-an-app-UI guidance), layered after the base prompt.
         const extraSystemPrompt = isString(data.system_prompt)
@@ -1285,7 +1360,7 @@ export class ChatTurnHandler {
                 sessionCheckpointOverride =
                     probeSession.checkpoint + 1 + newTurns.length;
                 loadFullHistory = async () => {
-                    const [rows] = await Message.paginate(threadId, { limit: 1000 });
+                    const rows = await loadRecentThreadRows(threadId);
                     const full = convertDbMessages(historySinceCompaction(rows));
                     full.unshift(systemChatMessage());
                     const scope = getRunTraceScope();
@@ -1306,7 +1381,7 @@ export class ChatTurnHandler {
                 // all (a far-back session still resumes via the slice path). A session
                 // older than the compaction cut is not one of them: searching only the
                 // compacted slice is what keeps the newest marker winning here too.
-                const [rows] = await Message.paginate(threadId, { limit: 1000 });
+                const rows = await loadRecentThreadRows(threadId);
                 const kept = historySinceCompaction(rows);
                 chatHistory = convertDbMessages(kept);
                 priorSession = lastMatchingProviderSession(kept, providerId, model);
@@ -1820,16 +1895,18 @@ export class ChatTurnHandler {
             }
             else if (this.deps.clientTools()[toolCall.name]) {
                 // Client-side tool — round-trip through the UI via the ToolBridge.
-                await this.session.send({
-                    type: "tool_call",
-                    thread_id: threadId,
-                    tool_call_id: toolCall.id,
-                    name: toolCall.name,
-                    args: toolCall.args
+                // A tool that spends money passes the turn's permission gate first.
+                toolResult = await dispatchClientTool(this.chatCapabilityRun, toolCall.name, toolCall.args ?? {}, async () => {
+                    await this.session.send({
+                        type: "tool_call",
+                        thread_id: threadId,
+                        tool_call_id: toolCall.id,
+                        name: toolCall.name,
+                        args: toolCall.args
+                    });
+                    const clientResult = await this.deps.toolBridge.createWaiter(toolCall.id, 300_000, threadId);
+                    return clientResult.result ?? clientResult.content ?? clientResult;
                 });
-                const clientResult = await this.deps.toolBridge.createWaiter(toolCall.id, 300_000, threadId);
-                toolResult =
-                    clientResult.result ?? clientResult.content ?? clientResult;
             }
             else {
                 toolResult = { error: `Tool "${toolCall.name}" not available` };
@@ -2063,7 +2140,7 @@ export class ChatTurnHandler {
          * turn that cannot run at all.
          */
         const compactThread = async (reason) => {
-            const [rows] = await Message.paginate(threadId, { limit: 1000 });
+            const rows = await loadRecentThreadRows(threadId);
             const cut = chooseCompactionCut(historySinceCompaction(rows), compaction.keepUserTurns, {
                 // Leave room for the summary, turn context and subsequent replies.
                 maxTokens: compactionThresholdTokens * 0.75 -
@@ -2177,6 +2254,7 @@ export class ChatTurnHandler {
                 executeTool: useTools ? effectiveExecuteTool : undefined,
                 maxIterations: MAX_TOOL_ROUNDS,
                 turnBudget,
+                effort: reasoningEffort,
                 sequentialTools: session ? true : undefined,
                 workspaceDir: chatWorkspace?.localDir ?? undefined,
                 skills: skillsForProvider,
@@ -3214,7 +3292,7 @@ export class ChatTurnHandler {
      *   6. Collect output_update results
      *   7. Send response message with typed content, then the terminal chunk
      */
-    async handleWorkflowMessage(data, requestSeq, signal) {
+    async handleWorkflowMessage(data, turnMessageId, requestSeq, signal) {
         const threadId = isString(data.thread_id) ? data.thread_id : "";
         const workflowId = isString(data.workflow_id) ? data.workflow_id : null;
         const providerId = isString(data.provider)
@@ -3256,7 +3334,7 @@ export class ChatTurnHandler {
                 messagesName ??
                 "messages";
             // Build chat history for params — matches Python
-            const [dbMessages] = await Message.paginate(threadId, { limit: 1000 });
+            const dbMessages = await loadRecentThreadRows(threadId);
             const inheritedTrace = getRunTraceScope();
             seedStoredToolProvenance(dbMessages);
             if (inheritedTrace) {
@@ -3280,7 +3358,12 @@ export class ChatTurnHandler {
             // Prepare params — matches Python's WorkflowMessageProcessor
             const params = {
                 [messageInputName]: currentMessage,
-                [messagesInputName]: [...chatHistorySerialized, currentMessage]
+                // The stored history already holds this turn's message; it is appended
+                // once, as `currentMessage`.
+                [messagesInputName]: [
+                    ...chatHistorySerialized.filter((_, i) => dbMessages[i].id !== turnMessageId),
+                    currentMessage
+                ]
             };
             if (isObjectLike(data.params)) {
                 Object.assign(params, data.params);