@nodetool-ai/websocket 0.7.0-rc.23 → 0.8.2

package/dist/session/chat-turn.d.ts

@@ -0,0 +1,337 @@
+import type { MessageContent, BaseProvider, ProcessingContext, PromptAssetRef } from "@nodetool-ai/runtime";
+import type { HydratedGraphData } from "@nodetool-ai/protocol";
+import { type CapabilityRun, type PermissionMode } from "@nodetool-ai/agents";
+import type { ClientSession } from "./client-session.js";
+import { type ActiveJob } from "./job-execution.js";
+import type { ToolBridge, WebSocketClientSessionOptions } from "../websocket-client-session.js";
+/**
+ * What a chat turn needs from the connection's job bookkeeping. A chat message
+ * bound to a workflow runs that workflow on the same concurrency accounting a
+ * `run_job` does, so the run has to be registered and released there rather
+ * than in a map of chat's own.
+ *
+ * Backed today by thin methods on the connection host; it is re-pointed at
+ * `JobExecutionManager` when the job-execution extraction lands.
+ */
+export interface ChatJobAccess {
+    /** Register a chat-driven run against the connection's concurrency slots. */
+    registerJob(jobId: string, active: ActiveJob): void;
+    /** Drop a run without draining the queue (the caller's finally does that). */
+    dropJob(jobId: string): void;
+    /** Drop a run and start whatever was queued behind it. */
+    releaseJob(jobId: string): void;
+    handleNodeProviderCost(active: ActiveJob, outbound: Record<string, unknown>): void;
+    runMeasuredCost(active: ActiveJob): number | null;
+}
+/**
+ * Everything a chat turn needs that is not the connection itself.
+ *
+ * The two `ToolBridge` instances are created by the host, not here: client
+ * frames land on the socket, and a dropped socket must be able to cancel every
+ * pending waiter without asking the chat handler anything.
+ */
+export interface ChatTurnDeps {
+    jobs: ChatJobAccess;
+    toolBridge: ToolBridge;
+    approvalBridge: ToolBridge;
+    /** The tool manifest the client declared for this connection. */
+    clientTools: () => Record<string, Record<string, unknown>>;
+    /** The connection's bearer token, for tools that call back into the API. */
+    authToken: () => string | null;
+    beforeRunJob?: WebSocketClientSessionOptions["beforeRunJob"];
+    defaults: {
+        provider: string;
+        model: string;
+    };
+    hydrateGraph: (graph: {
+        nodes: Array<Record<string, unknown>>;
+        edges: Array<Record<string, unknown>>;
+    }) => Promise<HydratedGraphData>;
+    configuredProviders: (userId: string) => Promise<Record<string, BaseProvider>>;
+    entityRefResolver: (userId: string) => {
+        getAssetInfo: (assetId: string) => Promise<{
+            id: string;
+            content_type: string;
+            name: string;
+            metadata: Record<string, unknown> | null;
+        } | null>;
+    };
+    resolveEntityReferenceImages: (userId: string, refs: PromptAssetRef[]) => Promise<Uint8Array[]>;
+    resolveSourceImageBytes: (data: Record<string, unknown>, mediaGeneration: Record<string, unknown>, userId: string) => Promise<Uint8Array | null>;
+    /**
+     * Every image and video the user attached, for the reference-to-video mode
+     * — which takes a set of references rather than the one source image
+     * {@link resolveSourceImageBytes} returns.
+     */
+    resolveReferenceMediaBytes: (data: Record<string, unknown>, mediaGeneration: Record<string, unknown>, userId: string) => Promise<{
+        images: Uint8Array[];
+        videos: Uint8Array[];
+    }>;
+}
+/**
+ * One connection's chat turns: the turn counter and abort controller, the
+ * per-thread permission state, the capability run, and the three message
+ * shapes a `chat_message` frame can take — an agent turn, a workflow run, or
+ * a media generation.
+ *
+ * It reaches the connection only through {@link ClientSession}. Everything
+ * else another region owns arrives in {@link ChatTurnDeps}.
+ */
+export declare class ChatTurnHandler {
+    private readonly session;
+    private readonly deps;
+    private chatRequestSeq;
+    /**
+     * Aborts the in-flight chat/inference turn. The seq counter above only filters
+     * stale output at yield boundaries — it cannot interrupt a provider that is
+     * blocked awaiting a response, nor tell one that owns a subprocess (the Claude
+     * Agent provider) to stop working. This signal does, and is threaded into
+     * every provider call the turn makes.
+     */
+    private chatAbort;
+    /**
+     * Per-thread set of tool names the user approved for the rest of the chat
+     * via "Allow for this chat". Persists across messages within a thread.
+     */
+    private chatSessionAllow;
+    /**
+     * Live permission mode for an in-flight turn. `set_permission_mode` writes
+     * here so switching to Auto mid-turn applies to the next gated call.
+     */
+    private chatTurnPermissionMode;
+    /**
+     * The capability run for the chat turn this connection is executing — the
+     * gate, the context, and everything a capability needs that only exists per
+     * turn. Built beside the toolbelt; the sandbox still calls the belt, and PR
+     * 11 is what switches the guest onto `run.invoke`.
+     */
+    private chatCapabilityRun;
+    /**
+     * Input window per `provider/model`, resolved once per connection and again
+     * whenever a turn selects a model this connection has not used.
+     */
+    private contextWindows;
+    /**
+     * The provider-reported size of each thread's last call, keyed by thread,
+     * with the `provider/model` it was measured on. The next turn's prompt is at
+     * least this large, and this counts what the local estimate cannot see.
+     */
+    private measuredThreadTokens;
+    constructor(session: ClientSession, deps: ChatTurnDeps);
+    /** The run built for the last chat turn — what PR 11 hands to the sandbox. */
+    getCapabilityRun(): CapabilityRun | null;
+    /**
+     * Open a chat/inference turn: cancel whatever was running and hand back the
+     * seq + signal the new turn runs under. A superseding message cancels the
+     * previous turn exactly as an explicit Stop does.
+     */
+    beginTurn(): {
+        seq: number;
+        signal: AbortSignal;
+        controller: AbortController;
+    };
+    /** Bump the turn counter without opening a new turn — what `stop` does. */
+    bumpRequestSeq(): void;
+    /** The turn a caller's `requestSeq` is compared against. */
+    get currentRequestSeq(): number;
+    /** Abort the in-flight turn, if any. Idempotent. */
+    cancel(): void;
+    /**
+     * Retire a turn that finished on its own. Clears the controller only when it
+     * is still the current one — a superseding turn has already installed its
+     * own, and clearing that would make a later Stop a no-op.
+     */
+    endTurn(controller: AbortController | null): void;
+    /** Resolve a client tool call this turn is waiting on. */
+    resolveToolResult(toolCallId: string, payload: Record<string, unknown>): void;
+    /**
+     * Apply a mid-turn permission-mode switch. Auto also releases every
+     * approval already waiting on this thread — the user just said yes to all
+     * of them.
+     */
+    setPermissionMode(threadId: string, mode: PermissionMode): void;
+    /**
+     * Which workflow decides where this conversation's files go.
+     *
+     * The workspace must not move between turns of one conversation: a file
+     * written in the previous message has to still be there in the next. The
+     * message's own `workflow_id` is not stable enough to key it on — the client
+     * attaches the id it has when it sends, so a turn sent before the thread list
+     * loaded carries none, resolves the default workspace instead of the
+     * workflow's, and the files the agent wrote a moment ago read as wiped. The
+     * thread's binding is the durable one, so it fills in whenever the message
+     * omits it.
+     */
+    private threadWorkspaceWorkflowId;
+    private ensureThreadExists;
+    /**
+     * Save a message dict to the database.
+     * Mirrors Python's _save_message_to_db_async: pops id, type, user_id before create.
+     */
+    private saveMessageToDb;
+    /**
+     * Persist raw image bytes carried on an assistant message (native providers
+     * that run a server-side image tool emit them inline) as real assets, and
+     * rewrite each such block to the wire shape `{ type: "image_url", image: {
+     * type: "image", asset_id, mimeType } }`. Blocks that already reference an
+     * asset (uri / asset_id, no raw data) and non-image blocks pass through
+     * untouched. Raw base64 is never persisted or sent.
+     */
+    materializeAssistantImageContent(content: MessageContent[], userId: string, workflowId: string | null, projectId?: string): Promise<Array<Record<string, unknown>>>;
+    /**
+     * Recursively process tool results, handling asset-like objects.
+     * Mirrors Python's RegularChatProcessor._process_tool_result().
+     *
+     * - Asset-like objects (have type + uri/data): materialized via storage
+     * - Date/datetime: converted to ISO string
+     * - Arrays/objects: recursed into
+     * - Primitives: returned as-is
+     */
+    private processToolResult;
+    /**
+     * Persist image bytes to temp storage and return a handle `view_image` can
+     * resolve — a bare `<uuid>.<ext>` storage key. No DB asset row is created, so
+     * these captures never clutter the user's asset library; the bytes live only
+     * in the request's temp storage. Returns null if there is no storage adapter
+     * or the write fails.
+     */
+    private storeTempImageAsset;
+    /**
+     * Replace embedded image pixels in a tool result — timeline `frames[]` or an
+     * `image_content` blob (e.g. `ui_3d_capture_view`) — with temp-asset handles.
+     * The model receives a handle and an instruction to call `view_image`, which
+     * is the single mechanism that pulls pixels into context. Keeps image bytes
+     * out of the standing chat history. Non-image results pass through untouched.
+     */
+    materializeToolResultImages(toolResult: unknown, ctx: ProcessingContext): Promise<unknown>;
+    /**
+     * Render the turn's memory block.
+     *
+     * Memory is user-scoped, but only **this thread's** memories are pasted in:
+     * the store grows for the life of the account, and a block that grew with it
+     * would eventually cost more than the turn. What the agent gets instead is
+     * this thread's notes in full plus a count of the ones saved elsewhere, so
+     * it knows to reach them with `memory_search` rather than assume the block
+     * is everything.
+     *
+     * Resource refs are used as stored (asset refs already carry the `asset://`
+     * uri captured at save time) — one indexed query, no per-asset lookups on
+     * the hot path. Best-effort: a DB hiccup returns an empty block rather than
+     * breaking the turn.
+     */
+    private buildMemoryBlock;
+    private buildGenerationBlock;
+    /**
+     * The user's skills, read once per turn.
+     *
+     * Two halves with different lifetimes, which is why the caller splits them.
+     * The catalog (name + description) changes only when the skills table does,
+     * so it belongs in the system prompt where a provider's automatic prefix
+     * cache can keep it. The body of a skill the message invoked with `/<name>`
+     * changes per turn, so it rides at the tail with the other volatile context.
+     *
+     * Best-effort like the memory block: a DB hiccup costs the skills, not the
+     * turn.
+     */
+    private loadUserSkills;
+    /**
+     * Round-trip a permission approval to the client and resolve with the
+     * user's decision. Emits a `tool_approval_request`, then waits for the
+     * matching `tool_approval_response` (resolved via {@link approvalBridge}).
+     * A cancelled wait (stop) is treated as a denial.
+     */
+    private requestToolApproval;
+    /**
+     * Open the bespoke secret dialog on the client and resolve with what the
+     * user did — never with what they typed.
+     *
+     * The value does not travel over this socket in either direction. The
+     * dialog writes it with the client's own `settings.secrets.upsert` call, so
+     * the credential never enters the chat transcript, the run's message log, or
+     * the model's context; this frame only asks, and the response only reports.
+     *
+     * A cancelled wait (the user pressed Stop) is a decline, which is the same
+     * fail-closed reading the approval prompts take.
+     */
+    private requestSecretEntry;
+    /**
+     * Execute a single node by type and return its output. Builds a one-node
+     * graph and runs it through a fresh `ExecutionSession` (@nodetool-ai/execution),
+     * then returns the
+     * node's completed result. Backs the `run_node` chat tool.
+     */
+    private runSingleNode;
+    /**
+     * Handle an incoming chat message.
+     *
+     * Mirrors Python's full 3-layer flow:
+     *   handle_chat_message → handle_message_impl → process_messages
+     *     → _run_processor + RegularChatProcessor.process()
+     *
+     * The processor sends messages to a queue. _run_processor reads them:
+     *   - type === "message" → persist to DB AND forward to client
+     *   - anything else → forward to client only
+     *
+     * RegularChatProcessor.process():
+     *   1. Prepend system prompt if first message isn't system role
+     *   2. while True: messages_to_send = chat_history + unprocessed_messages
+     *   3. Stream chunks (type: "chunk") — forwarded to client (not persisted)
+     *   4. On tool call: build assistant Message + tool result Message (type: "message")
+     *      → persisted to DB AND forwarded to client
+     *   5. If unprocessed_messages empty, break
+     *   6. Send done chunk + final assistant Message
+     */
+    handleChatMessage(data: Record<string, unknown>, requestSeq?: number, signal?: AbortSignal): Promise<void>;
+    private handlePersistedChatTurn;
+    /**
+     * Log a provider call for cost tracking — mirrors Python's _log_provider_call().
+     * Best-effort: never throws, logs warnings on failure.
+     */
+    _logProviderCall(userId: string, provider: BaseProvider, providerId: string, model: string, workflowId: string | null, projectId: string | null): Promise<void>;
+    /**
+     * Detect message input node names from a workflow graph.
+     * Mirrors Python's WorkflowMessageProcessor._detect_message_input_names().
+     *
+     * Scans graph nodes for types ending in .MessageInput / .MessageListInput
+     * and returns their data.name values.
+     */
+    private detectMessageInputNames;
+    /**
+     * Handle a chat_message with a `media_generation` payload by invoking the
+     * selected provider's textToImage / textToVideo API, storing the resulting
+     * asset(s), and returning them to the client as an assistant `Message`
+     * whose `content` is an array of `MessageImageContent` / `MessageVideoContent`
+     * blocks.
+     *
+     * The generated bytes are persisted via `ctx.storage.store()` so each
+     * output receives a stable URI the client can resolve as a server asset.
+     * The `media_generation` echo on the assistant message lets the UI render
+     * the generation header (model, variation count, resolution, etc.) in the
+     * conversation stream.
+     */
+    private handleMediaGenerationMessage;
+    /**
+     * Handle a chat message that targets a workflow.
+     *
+     * Mirrors Python's process_messages_for_workflow → WorkflowMessageProcessor/
+     * ChatWorkflowMessageProcessor flow:
+     *   1. Load workflow from DB
+     *   2. Detect message input node names from graph
+     *   3. Prepare params (serialized message + history)
+     *   4. Run workflow via ExecutionSession (@nodetool-ai/execution)
+     *   5. Stream events (job_update, node_update, output_update)
+     *   6. Collect output_update results
+     *   7. Send response message with typed content, then the terminal chunk
+     */
+    private handleWorkflowMessage;
+    /**
+     * If `event` is a tool_call_update, also emit a synthetic assistant message
+     * whose `tool_calls` array contains this call. The chat UI renders a
+     * persistent ToolCallCard from messages with tool_calls; tool_call_update
+     * by itself only drives transient "now running" state. We skip events that
+     * already carry `agent_execution_id` because those are routed to
+     * ExecutionTree via the agent_execution path.
+     */
+    private emitSyntheticToolCallCard;
+}
+//# sourceMappingURL=chat-turn.d.ts.map

package/dist/session/chat-turn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-turn.d.ts","sourceRoot":"","sources":["../../src/session/chat-turn.ts"],"names":[],"mappings":"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"}