@juspay/neurolink 12.28.4 → 12.29.1

package/dist/providers/openaiChatCompletionsBase.js

@@ -38,11 +38,11 @@ import { resolveRequestKind } from "../core/resolveRequestKind.js";
 import { appendJsonSchemaInstruction, hasNativeDoGenerate, runNativeGenerateLoop, } from "../core/nativeGenerateLoop.js";
 import { resolveToolExecutionRecords, toolCallsFromSummaries, } from "../core/toolExecutionRecorder.js";
 import { convertZodToJsonSchema } from "../utils/schemaConversion.js";
-import { coerceJsonToSchema, schemaAccepts } from "../utils/json/coerce.js";
+import { coerceJsonToSchema, recoverScalarRoot, schemaAccepts, } from "../utils/json/coerce.js";
 import { resolveToolChoice } from "../utils/toolChoice.js";
 import { transformToolExecutions } from "../utils/transformationUtils.js";
 import { withProviderRetry } from "../utils/providerRetry.js";
-import { isSchemaComplexityError, isToolsSchemaConflictError, } from "../core/modules/structuredOutputPolicy.js";
+import { isResponseFormatUnsupportedError, isSchemaComplexityError, isToolsSchemaConflictError, } from "../core/modules/structuredOutputPolicy.js";
 import { resolveDeferredTool } from "../tools/toolDiscovery.js";
 import { buildAPIError, buildBody, buildToolsForOpenAI, buildWireToolNameMaps, createDeferredAnalytics, ensureJsonWordInBody, estimateWireTokens, mapNeuroLinkToolChoice, mergeUsage, messageBuilderToOpenAI, parseSSEStream, stringifyToolOutput, stripTrailingSlash, v3ResponseFormatToOpenAI, v3ToolChoiceToOpenAI, v3ToolsToOpenAI, } from "./openaiChatCompletionsClient.js";
 import { createStreamChannel } from "../core/streamChannel.js";
@@ -75,6 +75,30 @@ const yieldsSchemaValidObject = (text, schema) => {
     const coerced = coerceJsonToSchema(text, schema);
     return coerced !== null && schemaAccepts(schema, coerced.structuredData);
 };
+/**
+ * Resolve a model answer against the requested schema, accepting the roots a
+ * ValidationSchema actually allows.
+ *
+ * `coerceJsonToSchema` scans for a balanced object or array span, so it
+ * recovers object and array roots but never a scalar one: a schema of
+ * `z.string()` answered with `"sunny"` finds no span and yields null. That is
+ * why `recoverScalarRoot` exists — it was already the second half of this
+ * decision on the neurolink.ts generate path (`recoverStructuredData`), and
+ * was simply never wired into the provider path. Without it a scalar-root
+ * schema silently produces no structured output no matter how correctly the
+ * model answers.
+ *
+ * Returns `undefined` when neither route accepts, which callers treat as "the
+ * model did not produce the value".
+ */
+const resolveAgainstSchema = (text, schema) => {
+    const coerced = coerceJsonToSchema(text, schema);
+    if (coerced !== null && schemaAccepts(schema, coerced.structuredData)) {
+        return coerced.structuredData;
+    }
+    const scalar = recoverScalarRoot(text, schema);
+    return scalar.kind === "accepted" ? scalar.value : undefined;
+};
 // Pull one native chunk at a time and forward cancellation to its iterator.
 const chunksToV3Stream = (source, completion, cancel) => {
     const iterator = source[Symbol.asyncIterator]();
@@ -976,7 +1000,9 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
         }
         catch (error) {
             const recoverable = responseFormat !== undefined &&
-                (isToolsSchemaConflictError(error) || isSchemaComplexityError(error));
+                (isToolsSchemaConflictError(error) ||
+                    isSchemaComplexityError(error) ||
+                    isResponseFormatUnsupportedError(error));
             if (!recoverable) {
                 throw error;
             }
@@ -1330,6 +1356,176 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
         }
         return loop;
     }
+    /**
+     * Resolve the parsed object for a `stream({ schema })` turn, after the
+     * stream has been drained.
+     *
+     * Before this, streaming never sent `response_format` under any condition —
+     * unlike the generate path, where the gap is only tools-dependent (see
+     * suppressResponseFormatWithTools), so `structuredData` was never available
+     * to a streaming caller at all. `executeStream` now sends `response_format`
+     * on the wire whenever a schema is present and tools aren't suppressing it;
+     * this method covers what's left: the common case where the streamed text
+     * already parses against the schema, and the tools-suppressed case, which is
+     * re-asked once without tools — the same recovery `reformatWithoutTools`
+     * performs for generate(), reusing its acceptance rule
+     * (`yieldsSchemaValidObject`) and its two-strategy fallback (native
+     * `response_format` first, the schema spelled into the prompt if a vendor
+     * rejects that).
+     *
+     * Returns `undefined` on every failure path rather than throwing: a turn
+     * whose text the caller has already consumed and streamed to their UI must
+     * not be turned into an error by a follow-up they never asked for.
+     */
+    async resolveStreamStructuredData(args) {
+        const { schema, schemaJson, text, conversation, modelId, abortSignal, options, } = args;
+        // A function, not a captured boolean: the signal is read once before the
+        // re-ask and again after it, and it can legitimately flip in between — a
+        // const read of `abortSignal.aborted` would let the compiler narrow the
+        // second read away (it cannot know the underlying signal mutates between
+        // the two checks).
+        const isCancelled = () => abortSignal?.aborted === true;
+        // Nothing streamed — a middleware short-circuit, or a turn that only
+        // called tools. Nothing to parse and nothing to restate.
+        if (text.trim().length === 0) {
+            return undefined;
+        }
+        // The happy path: the streamed answer already satisfies the schema (this
+        // is what sending `response_format` on the wire was for), so no second
+        // request.
+        const streamedValue = resolveAgainstSchema(text, schema);
+        if (streamedValue !== undefined) {
+            return {
+                data: streamedValue,
+                usage: { inputTokens: 0, outputTokens: 0 },
+            };
+        }
+        // No conversation means `doStream` never ran (a middleware short
+        // -circuited and returned its own stream), so there is no turn for a
+        // re-ask to build on.
+        if (!conversation || isCancelled()) {
+            return undefined;
+        }
+        try {
+            const model = await this.getAISDKModelWithMiddleware(options);
+            if (!hasNativeDoGenerate(model)) {
+                return undefined;
+            }
+            logger.warn(`[${this.providerName}] streamed answer is not schema-valid — re-asking once without tools`, { provider: this.providerName, model: modelId });
+            const doGenerate = model.doGenerate.bind(model);
+            // Every request here is billed, including one whose ANSWER is
+            // discarded (a native-format attempt the vendor rejected, or a re-ask
+            // that came back off-schema). Accumulate as each response lands rather
+            // than reading the survivor, for the same reason the generate path
+            // does: otherwise a two-request recovery reports as one.
+            const billed = { inputTokens: 0, outputTokens: 0 };
+            const runLoop = (conv, format) => runNativeGenerateLoop({
+                doGenerate,
+                conversation: conv,
+                toolsRecord: {},
+                ...(format ? { responseFormat: format } : {}),
+                maxSteps: 1,
+                ...(options.maxTokens
+                    ? { maxOutputTokens: options.maxTokens }
+                    : {}),
+                ...(abortSignal ? { abortSignal } : {}),
+                runStep: (call) => call(),
+            }, []).then((loopResult) => {
+                billed.inputTokens += loopResult.inputTokens;
+                billed.outputTokens += loopResult.outputTokens;
+                return loopResult;
+            });
+            // `conversation` here is the STREAMING loop's own array (see
+            // executeToolBatch), which is already wire-shaped: an assistant turn
+            // that called a tool carries a real `tool_calls` field and the matching
+            // reply is a `{role: "tool", tool_call_id, content}` message — not the
+            // ai-sdk-parts shape `messageBuilderToOpenAI` expects from `doGenerate`'s
+            // `options.prompt`. Re-running `runNativeGenerateLoop` on those turns
+            // unchanged would send them through `messageBuilderToOpenAI` a second
+            // time, which only ever reads the ai-sdk-parts fields — it silently
+            // drops `tool_calls` (it inspects `content` for `{type:"tool-call",
+            // toolCallId}` parts, never a wire `tool_calls` property) and blanks
+            // `tool_call_id` to `""` (it reads `toolCallId`, the pre-wire field,
+            // never the wire `tool_call_id`). The result is a `tool` message with no
+            // matching preceding tool call, which a real vendor rejects outright.
+            // None of that history is actually needed for this re-ask: the
+            // assistant turn appended below already restates whatever the tool call
+            // produced, in the model's own words, so the tool exchange itself is
+            // dropped rather than repaired.
+            const conversationWithoutToolExchange = conversation.filter((message) => {
+                if (message.role === "tool") {
+                    return false;
+                }
+                const toolCalls = message.tool_calls;
+                return !(message.role === "assistant" &&
+                    Array.isArray(toolCalls) &&
+                    toolCalls.length > 0);
+            });
+            const reaskConversation = [
+                ...conversationWithoutToolExchange,
+                { role: "assistant", content: text },
+                {
+                    role: "user",
+                    content: 
+                    // "value", not "object": ValidationSchema also accepts array and
+                    // scalar roots (z.array(...), z.string()).
+                    "Return that same answer as a single JSON value conforming to " +
+                        "the required schema. No prose before or after it, and no " +
+                        "markdown code fence.",
+                },
+            ];
+            let reformatted;
+            try {
+                reformatted = await runLoop(reaskConversation, {
+                    type: "json",
+                    schema: schemaJson,
+                });
+            }
+            catch (nativeFormatError) {
+                if (isCancelled()) {
+                    throw nativeFormatError;
+                }
+                logger.warn(`[${this.providerName}] the stream re-ask's response_format was rejected — retrying with the schema in the prompt`, {
+                    provider: this.providerName,
+                    model: modelId,
+                    error: nativeFormatError instanceof Error
+                        ? nativeFormatError.message
+                        : String(nativeFormatError),
+                });
+                reformatted = await runLoop(appendJsonSchemaInstruction(reaskConversation, schemaJson), undefined);
+            }
+            // Sending response_format is not the same as being obeyed: accept the
+            // reformat only if it actually produced the object.
+            const reaskedValue = resolveAgainstSchema(reformatted.text, schema);
+            if (reaskedValue === undefined) {
+                logger.warn(`[${this.providerName}] the tool-free stream re-ask did not yield a schema-valid value either; leaving structuredData unset`, { provider: this.providerName, model: modelId });
+                return { data: undefined, usage: billed };
+            }
+            return { data: reaskedValue, usage: billed };
+        }
+        catch (error) {
+            // A caller who cancelled deserves their cancellation. Swallowing here
+            // resolved a cancelled turn as though the abort never happened — the
+            // inner handler already rethrows for exactly that case, and this outer
+            // one was catching its rethrow and turning it back into `undefined`.
+            //
+            // Our OWN turn deadline is the one thing that must NOT propagate: the
+            // caller has already consumed the streamed text, and a deadline reached
+            // during a follow-up they never asked for must not retroactively turn
+            // their answer into an error. The two arrive on the same composed
+            // signal but are distinguishable by reason, since the turn timer aborts
+            // with a TimeoutError. Same rule as the generate path's reformat guard.
+            if (isCancelled() && !(abortSignal?.reason instanceof TimeoutError)) {
+                throw error;
+            }
+            logger.warn(`[${this.providerName}] the tool-free structured-output re-ask failed for a stream; leaving structuredData unset`, {
+                provider: this.providerName,
+                model: modelId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return undefined;
+        }
+    }
     async executeStream(options, _analysisSchema) {
         this.validateStreamOptions(options);
         const startTime = Date.now();
@@ -1374,6 +1570,23 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
             timeoutController?.cleanup();
             throw setupErr;
         }
+        // Structured output rides `response_format`, mirroring the generate
+        // path's policy (see suppressResponseFormatWithTools) — the streaming
+        // path previously never sent it AT ALL, regardless of tools, so
+        // `structuredData` was never available to a streaming caller in any
+        // case. Computed once, up front, exactly like the generate path: mid-turn
+        // tool hydration (tools.discovery) does not retroactively change whether
+        // this turn asked for JSON.
+        const schemaJson = options.schema
+            ? convertZodToJsonSchema(options.schema)
+            : undefined;
+        const hasToolsForStream = !!openAITools && openAITools.length > 0;
+        const responseFormatSuppressed = schemaJson !== undefined &&
+            hasToolsForStream &&
+            this.suppressResponseFormatWithTools();
+        const responseFormat = schemaJson && !responseFormatSuppressed
+            ? this.adjustResponseFormat(v3ResponseFormatToOpenAI({ type: "json", schema: schemaJson }), modelId)
+            : undefined;
         const url = this.getChatCompletionsURL(modelId);
         const fetchImpl = createProxyFetch();
         const maxSteps = options.maxSteps || DEFAULT_MAX_STEPS;
@@ -1416,6 +1629,14 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
             ...(options.topP !== undefined ? { topP: options.topP } : {}),
         };
         let loopPromise;
+        // The wire conversation only exists once `doStream` actually runs, and it
+        // is built from the MIDDLEWARE-TRANSFORMED prompt, so it cannot be
+        // reconstructed from `promptMessages` afterwards. Captured here so the
+        // post-drain structured-output re-ask (resolveStreamStructuredData) can
+        // build on the same turn the model actually saw. Stays undefined when a
+        // middleware short-circuits the request — the case where there is no
+        // turn to build on at all.
+        let loopConversation;
         const providerNameForLoop = this.providerName;
         const streamBaseModel = {
             specificationVersion: "v3",
@@ -1437,6 +1658,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                     ? params.prompt
                     : promptMessages;
                 const conversation = messageBuilderToOpenAI(transformedPrompt, wireNameMaps?.toWire);
+                loopConversation = conversation;
                 const sampled = {
                     ...options,
                     ...(typeof params?.maxOutputTokens === "number"
@@ -1466,6 +1688,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                     closeChannel: channel.close,
                     resolveUsage,
                     resolveFinish,
+                    responseFormat,
                 });
                 const completion = loopPromise.then(() => Promise.all([usagePromise, finishPromise]).then(([usage, reason]) => ({
                     type: "finish",
@@ -1545,14 +1768,32 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
             });
         }
         const providerName = this.providerName;
+        // Not an arrow function — `transformedStream` doesn't have `this` bound,
+        // so it needs its own capture to reach resolveStreamStructuredData.
+        const self = this;
+        // Built here rather than inline in `result` so the generator below can
+        // fill in `structuredData` after the stream drains. Same mutable
+        // -reference contract `finishReason`/`stopReason` on this object already
+        // rely on: a wrapper that spreads the result cannot snapshot a value that
+        // does not exist yet.
+        const streamMetadata = {
+            startTime,
+            streamId: `${this.providerName}-${Date.now()}`,
+        };
         const transformedStream = async function* () {
             let contentYielded = 0;
+            // Only accumulated when a schema was actually requested — every other
+            // turn keeps paying nothing for this.
+            let schemaText = "";
             try {
                 for await (const chunk of chunkSource) {
                     if ("content" in chunk &&
                         typeof chunk.content === "string" &&
                         chunk.content.length > 0) {
                         contentYielded++;
+                        if (options.schema) {
+                            schemaText += chunk.content;
+                        }
                     }
                     yield chunk;
                 }
@@ -1560,6 +1801,47 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                 // `loopPromise` is undefined when a middleware blocked the request
                 // before `doStream` ran, in which case there is no loop to surface.
                 await loopPromise;
+                // Structured output for a `stream({ schema })` turn. Runs HERE —
+                // after the stream is fully drained — so a tool-free re-ask (when the
+                // streamed answer isn't already schema-valid) never reaches
+                // `wrapStream` and a caller's guardrail middleware never sees a
+                // second stream it did not ask for.
+                //
+                // When a middleware short-circuited the request, `loopPromise` is
+                // undefined and `schemaText` is empty, so this resolves to nothing
+                // and the field stays absent rather than hanging a reader.
+                if (options.schema && schemaJson) {
+                    const resolved = await self.resolveStreamStructuredData({
+                        schema: options.schema,
+                        schemaJson,
+                        text: schemaText,
+                        conversation: loopConversation,
+                        modelId,
+                        abortSignal,
+                        options,
+                    });
+                    // Assign only when there is something to assign. A bare
+                    // `= resolved?.data` creates the own property even when the value
+                    // is undefined, so `"structuredData" in metadata` reports true for
+                    // a turn that produced no object — which is precisely the check the
+                    // field's own contract tells readers to use to detect absence.
+                    if (resolved?.data !== undefined) {
+                        streamMetadata.structuredData = resolved.data;
+                    }
+                    // Only when a re-ask actually spent something. The common case is
+                    // the streamed answer already parsing, which costs nothing extra
+                    // and leaves the field absent rather than reporting a zero.
+                    if (resolved &&
+                        (resolved.usage.inputTokens > 0 || resolved.usage.outputTokens > 0)) {
+                        streamMetadata.structuredDataUsage = resolved.usage;
+                        logger.info(`[${providerName}] structured-output re-ask billed separately from the streamed turn`, {
+                            provider: providerName,
+                            model: modelId,
+                            inputTokens: resolved.usage.inputTokens,
+                            outputTokens: resolved.usage.outputTokens,
+                        });
+                    }
+                }
                 // No-output path: stream completed normally but yielded zero text.
                 // Build an enriched sentinel + stamp the active OTel span so
                 // Pipeline B (ContextEnricher) surfaces a WARNING-level Langfuse
@@ -1615,10 +1897,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                 streamingMode: true,
             }),
             toolsUsed,
-            metadata: {
-                startTime,
-                streamId: `${this.providerName}-${Date.now()}`,
-            },
+            metadata: streamMetadata,
         };
         // Lazy getter: every read transforms the live `toolExecutionSummaries`
         // through the canonical `transformToolExecutions()` so consumers see
@@ -1642,7 +1921,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
         return result;
     }
     async runStreamLoop(args) {
-        const { maxSteps, modelId, url, fetchImpl, abortSignal, options, conversation, openAITools, openAIToolChoice, toolsRecord, toolNameFromWire, emitter, toolsUsed, toolExecutionSummaries, pushChunk, closeChannel, resolveUsage, resolveFinish, } = args;
+        const { maxSteps, modelId, url, fetchImpl, abortSignal, options, conversation, openAITools, openAIToolChoice, toolsRecord, toolNameFromWire, emitter, toolsUsed, toolExecutionSummaries, pushChunk, closeChannel, resolveUsage, resolveFinish, responseFormat, } = args;
         // Hoisted above the try so the catch can resolve the usage accumulated
         // by steps that completed BEFORE the failure — those steps were billed.
         let stepFinish = null;
@@ -1743,6 +2022,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                     openAITools,
                     openAIToolChoice,
                     pushChunk,
+                    responseFormat,
                 });
                 lastObservedPromptTokens = stepResult.usage?.prompt_tokens;
                 stepFinish = stepResult.finishReason;
@@ -1800,6 +2080,9 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                 ? { toolChoice: args.openAIToolChoice }
                 : {}),
             streaming: true,
+            ...(args.responseFormat
+                ? { responseFormat: args.responseFormat }
+                : {}),
         }), args.modelId));
         // The initial fetch gets 429/5xx retry-with-backoff via the same
         // primitive the non-streaming path already uses (withProviderRetry).

package/dist/server/routes/claudeProxyRoutes.js

@@ -3556,7 +3556,18 @@ async function loadClaudeProxyAccounts(args) {
                 existingState.consecutiveRefreshFailures = 0;
             }
             else {
-                logger.debug(`[proxy] skipping disabled account=${key.split(":")[1] ?? key}`);
+                const label = key.split(":")[1] ?? key;
+                if (existingState.permanentlyDisabled) {
+                    logger.debug(`[proxy] skipping disabled account=${label}`);
+                }
+                else {
+                    // A flag set outside this worker (the CLI, another worker, an older
+                    // build) is otherwise invisible at the default level. Say once that
+                    // the account left the pool; re-enabling clears the marker, so the
+                    // next disable is announced again.
+                    const disabledAt = inventory[key].disabledAt;
+                    logger.always(`[proxy] account=${label} is disabled in the token store (reason=${disabledReason ?? "unknown"}${disabledAt ? `, since ${new Date(disabledAt).toISOString()}` : ""}); left out of the pool. Re-enable with: neurolink auth enable ${key}`);
+                }
                 existingState.permanentlyDisabled = true;
                 if (disabledReason === "entitlement_blocked") {
                     entitlementBlockedLabels.push(key.split(":")[1] ?? key);

package/dist/server/utils/validation.d.ts

@@ -23,6 +23,40 @@ export declare const AgentExecuteRequestSchema: z.ZodObject<{
     sessionId: z.ZodOptional<z.ZodString>;
     userId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
+/**
+ * Options a WebSocket `generate`/`stream` message may pass through to
+ * `neurolink.generate()`/`.stream()`. Deliberately an allowlist, not the full
+ * `GenerateOptions`/`StreamOptions` shape: the raw client JSON is untrusted,
+ * and `GenerateOptions.credentials` in particular carries a per-provider
+ * `baseURL` (see `NeurolinkCredentials`) that would otherwise let any caller
+ * redirect the server's own outbound request to an arbitrary host (SSRF) or
+ * swap in their own API key. `z.object` strips unknown keys by default, so
+ * `credentials` and anything else outside this list never reaches the SDK
+ * call — the same posture `AgentExecuteRequestSchema` already takes for the
+ * equivalent HTTP route.
+ */
+export declare const WebSocketAgentOptionsSchema: z.ZodObject<{
+    provider: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    systemPrompt: z.ZodOptional<z.ZodString>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+    maxSteps: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * WebSocket `generate`/`stream` message payload schema.
+ */
+export declare const WebSocketAgentRequestSchema: z.ZodObject<{
+    prompt: z.ZodString;
+    options: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+        systemPrompt: z.ZodOptional<z.ZodString>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        maxTokens: z.ZodOptional<z.ZodNumber>;
+        maxSteps: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 /**
  * Tool execute request schema
  */

package/dist/server/utils/validation.js

@@ -28,6 +28,33 @@ export const AgentExecuteRequestSchema = z.object({
     sessionId: z.string().optional(),
     userId: z.string().optional(),
 });
+/**
+ * Options a WebSocket `generate`/`stream` message may pass through to
+ * `neurolink.generate()`/`.stream()`. Deliberately an allowlist, not the full
+ * `GenerateOptions`/`StreamOptions` shape: the raw client JSON is untrusted,
+ * and `GenerateOptions.credentials` in particular carries a per-provider
+ * `baseURL` (see `NeurolinkCredentials`) that would otherwise let any caller
+ * redirect the server's own outbound request to an arbitrary host (SSRF) or
+ * swap in their own API key. `z.object` strips unknown keys by default, so
+ * `credentials` and anything else outside this list never reaches the SDK
+ * call — the same posture `AgentExecuteRequestSchema` already takes for the
+ * equivalent HTTP route.
+ */
+export const WebSocketAgentOptionsSchema = z.object({
+    provider: z.string().optional(),
+    model: z.string().optional(),
+    systemPrompt: z.string().optional(),
+    temperature: z.number().min(0).max(2).optional(),
+    maxTokens: z.number().positive().optional(),
+    maxSteps: z.number().positive().optional(),
+});
+/**
+ * WebSocket `generate`/`stream` message payload schema.
+ */
+export const WebSocketAgentRequestSchema = z.object({
+    prompt: z.string().min(1, "Prompt is required"),
+    options: WebSocketAgentOptionsSchema.optional(),
+});
 /**
  * Tool execute request schema
  */

package/dist/server/websocket/WebSocketHandler.d.ts

@@ -4,7 +4,8 @@
  * Provides cross-framework WebSocket handling for real-time AI interactions.
  * Supports connection management, message routing, and graceful shutdown.
  */
-import type { WebSocketConfig, WebSocketHandler as IWebSocketHandler, WebSocketConnection, WebSocketMessage, AuthenticatedUser } from "../../types/index.js";
+import type { WebSocketConfig, WebSocketHandler as IWebSocketHandler, WebSocketConnection, WebSocketMessage, WebSocketRequestId, AuthenticatedUser } from "../../types/index.js";
+import type { NeuroLink } from "../../neurolink.js";
 /**
  * WebSocket connection manager
  */
@@ -91,7 +92,7 @@ export declare class WebSocketMessageRouter {
     /**
      * Register a message route
      */
-    route(type: string, handler: (connection: WebSocketConnection, payload: unknown) => Promise<unknown>): void;
+    route(type: string, handler: (connection: WebSocketConnection, payload: unknown, requestId?: WebSocketRequestId) => Promise<unknown>): void;
     /**
      * Handle incoming message
      */
@@ -101,7 +102,4 @@ export declare class WebSocketMessageRouter {
      */
     getRoutes(): string[];
 }
-/**
- * Create a WebSocket handler for AI agent interactions
- */
-export declare function createAgentWebSocketHandler(_neurolink: unknown): IWebSocketHandler;
+export declare function createAgentWebSocketHandler(neurolink: NeuroLink): IWebSocketHandler;