glirastes 0.4.0 → 0.5.1

package/dist/cjs/server/adapters/nextjs/direct-command.d.ts

@@ -0,0 +1,75 @@
+import { type ChatCommandInvocation } from '../../../contracts/chat-command.js';
+import type { ManagedTurnGuard } from '../../../runtime/managed-turn.js';
+import type { TurnMetricsRecorder } from '../../../runtime/metrics/turn-recorder.js';
+import type { PiiShield, ToolRegistry } from '../../../types.js';
+import type { ApprovalBinder, ApprovalStore } from './approval-binding.js';
+/** A direct command in the latest user message, and where its turn stands. */
+export interface DirectCommandRequest {
+    readonly invocation: ChatCommandInvocation;
+    readonly label: string;
+    /** The user's answer to this command's confirmation request. */
+    readonly approval?: {
+        readonly toolCallId: string;
+        /** The approval id the client sent back; `runDirectCommand` verifies its binding. */
+        readonly approvalId: string;
+        readonly approved: boolean;
+    };
+    /** The command already ran or was refused; nothing is left to do. */
+    readonly settled?: boolean;
+}
+/**
+ * Reads the latest user message as a direct command. The assistant message
+ * that follows it (an approval continuation) decides whether the command
+ * still waits for its confirmation answer or is settled.
+ */
+export declare function resolveDirectCommand(messages: ReadonlyArray<unknown>): DirectCommandRequest | undefined;
+/** The model's copy of the history: earlier command markers removed, the visible label kept. */
+export declare function stripChatCommandMessages(messages: ReadonlyArray<unknown>): unknown[];
+/**
+ * The model's copy of a message with the arguments of its direct-command
+ * tool parts pseudonymized. A model-written call is pseudonymized already
+ * (it is rehydrated only at execution), but a command's arguments are what
+ * the user typed, and later model turns replay the call to the provider.
+ * The same session as the user messages' labels, so one value gets one
+ * pseudonym everywhere.
+ */
+export declare function pseudonymizeCommandToolInputs(message: Record<string, unknown>, shield: PiiShield, sessionId: string): Promise<Record<string, unknown>>;
+/**
+ * The registry key of the command's tool: the tool whose id is the
+ * definition id, else the key spelled like it. SDK built-ins never run as
+ * direct commands.
+ */
+export declare function resolveCommandToolName(registry: ToolRegistry, tool: string): string | undefined;
+export interface RunDirectCommandOptions {
+    command: DirectCommandRequest;
+    /** The turn's registry, built exactly like for a model turn. */
+    registry: ToolRegistry;
+    /** `toolsToAiTools(registry, …)`, after the same wrappers as the model path. */
+    tools: Record<string, unknown>;
+    managedTurn?: ManagedTurnGuard;
+    turnMetrics?: TurnMetricsRecorder;
+    /**
+     * Binds the approval request to the command's tool call and verifies the
+     * answer. Without it a tool that needs confirmation neither asks nor runs
+     * (`approval_binding_unavailable`): an unbound approval would let a forged
+     * history run the command.
+     */
+    approvals?: ApprovalBinder;
+    /** Optional single-use store for verified approvals. */
+    approvalStore?: ApprovalStore;
+    /** The scope handed to the store with each approval (see `approvalScope`); default `''`. */
+    approvalScope?: string;
+    onError?: (error: unknown) => void;
+    /** Suffix of the tool call and approval ids; default 20 random hex characters. */
+    generateId?: () => string;
+}
+/**
+ * Runs a direct command without a model call. The tool goes through the
+ * same AI SDK wrapper as on the model path: input schema, the managed guard
+ * (manifest, principal, roles, revocation, budget), confirmation
+ * (`needsApproval` / the policy) and audit. A tool that needs confirmation
+ * answers with an AI SDK approval request; the approval continuation runs
+ * it. One content-free metric event per request: no model, unknown cost,
+ * the executed call (or none) as tool count.
+ */
+export declare function runDirectCommand(options: RunDirectCommandOptions): Promise<Response>;

package/dist/cjs/server/adapters/nextjs/direct-command.js

@@ -0,0 +1,322 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveDirectCommand = resolveDirectCommand;
+exports.stripChatCommandMessages = stripChatCommandMessages;
+exports.pseudonymizeCommandToolInputs = pseudonymizeCommandToolInputs;
+exports.resolveCommandToolName = resolveCommandToolName;
+exports.runDirectCommand = runDirectCommand;
+const node_crypto_1 = require("node:crypto");
+const ai_1 = require("ai");
+const chat_command_js_1 = require("../../../contracts/chat-command.js");
+const engine_js_1 = require("../../../runtime/ai-sdk/engine.js");
+const local_tool_bindings_js_1 = require("../../../runtime/local-tool-bindings.js");
+const cost_js_1 = require("../../../runtime/metrics/cost.js");
+const tool_discovery_js_1 = require("./tool-discovery.js");
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function textOf(message) {
+    if (typeof message.content === 'string')
+        return message.content;
+    if (!Array.isArray(message.parts))
+        return '';
+    return message.parts
+        .filter((part) => isRecord(part) && part.type === 'text' && typeof part.text === 'string')
+        .map((part) => part.text)
+        .join('\n');
+}
+/**
+ * Reads the latest user message as a direct command. The assistant message
+ * that follows it (an approval continuation) decides whether the command
+ * still waits for its confirmation answer or is settled.
+ */
+function resolveDirectCommand(messages) {
+    let index = messages.length - 1;
+    while (index >= 0 && !(isRecord(messages[index]) && messages[index].role === 'user'))
+        index -= 1;
+    if (index < 0)
+        return undefined;
+    const parsed = (0, chat_command_js_1.parseChatCommandMessage)(textOf(messages[index]));
+    if (!parsed)
+        return undefined;
+    const next = messages[index + 1];
+    if (next === undefined)
+        return parsed;
+    const parts = isRecord(next) && next.role === 'assistant' && Array.isArray(next.parts) ? next.parts : [];
+    const call = parts.find((part) => isRecord(part) && (0, chat_command_js_1.isChatCommandToolCallId)(part.toolCallId));
+    if (call?.state === 'approval-responded' && isRecord(call.approval)) {
+        return {
+            ...parsed,
+            approval: {
+                toolCallId: call.toolCallId,
+                approvalId: typeof call.approval.id === 'string' ? call.approval.id : '',
+                approved: call.approval.approved === true,
+            },
+        };
+    }
+    return { ...parsed, settled: true };
+}
+/** The model's copy of the history: earlier command markers removed, the visible label kept. */
+function stripChatCommandMessages(messages) {
+    return messages.map((message) => {
+        if (!isRecord(message) || message.role !== 'user')
+            return message;
+        if (typeof message.content === 'string') {
+            const content = (0, chat_command_js_1.stripChatCommandMarkers)(message.content);
+            return content === message.content ? message : { ...message, content };
+        }
+        if (!Array.isArray(message.parts))
+            return message;
+        let changed = false;
+        const parts = message.parts.map((part) => {
+            if (!isRecord(part) || part.type !== 'text' || typeof part.text !== 'string')
+                return part;
+            const text = (0, chat_command_js_1.stripChatCommandMarkers)(part.text);
+            if (text === part.text)
+                return part;
+            changed = true;
+            return { ...part, text };
+        });
+        return changed ? { ...message, parts } : message;
+    });
+}
+/** Nesting deeper than this is not walked: it is replaced instead of reaching the model unchecked. */
+const MAX_PSEUDONYMIZED_DEPTH = 8;
+const REDACTED = '[redacted]';
+/** Pseudonymizes every string of a value in order; numbers, booleans and null stay. */
+async function pseudonymizeStrings(value, shield, sessionId, depth = 0) {
+    if (typeof value === 'string')
+        return shield.outbound(value, sessionId);
+    if (typeof value !== 'object' || value === null)
+        return value;
+    if (depth >= MAX_PSEUDONYMIZED_DEPTH)
+        return REDACTED;
+    if (Array.isArray(value)) {
+        const items = [];
+        for (const item of value)
+            items.push(await pseudonymizeStrings(item, shield, sessionId, depth + 1));
+        return items;
+    }
+    const entries = [];
+    for (const [key, entry] of Object.entries(value)) {
+        entries.push([key, await pseudonymizeStrings(entry, shield, sessionId, depth + 1)]);
+    }
+    return Object.fromEntries(entries);
+}
+/**
+ * The model's copy of a message with the arguments of its direct-command
+ * tool parts pseudonymized. A model-written call is pseudonymized already
+ * (it is rehydrated only at execution), but a command's arguments are what
+ * the user typed, and later model turns replay the call to the provider.
+ * The same session as the user messages' labels, so one value gets one
+ * pseudonym everywhere.
+ */
+async function pseudonymizeCommandToolInputs(message, shield, sessionId) {
+    if (!Array.isArray(message.parts))
+        return message;
+    let changed = false;
+    const parts = [];
+    for (const part of message.parts) {
+        if (!isRecord(part) || !(0, chat_command_js_1.isChatCommandToolCallId)(part.toolCallId)) {
+            parts.push(part);
+            continue;
+        }
+        // `rawInput` stands in for `input` when a call failed validation.
+        const next = { ...part };
+        for (const key of ['input', 'rawInput']) {
+            if (part[key] === undefined)
+                continue;
+            next[key] = await pseudonymizeStrings(part[key], shield, sessionId);
+            changed = true;
+        }
+        parts.push(next);
+    }
+    return changed ? { ...message, parts } : message;
+}
+/**
+ * The registry key of the command's tool: the tool whose id is the
+ * definition id, else the key spelled like it. SDK built-ins never run as
+ * direct commands.
+ */
+function resolveCommandToolName(registry, tool) {
+    const builtins = new Set(tool_discovery_js_1.NON_DOMAIN_TOOL_NAMES);
+    const names = Object.keys(registry).filter((name) => !builtins.has(name));
+    return names.find((name) => registry[name].id === tool)
+        ?? names.find((name) => name === tool || name === (0, local_tool_bindings_js_1.modelFacingToolName)(tool));
+}
+/** Content-free reason for the client: a denial code from the guard, never a backend message. */
+function failureCode(error) {
+    const message = error instanceof Error ? error.message : '';
+    const denied = /^Tool execution denied: ([a-z_]{1,80})\b/.exec(message);
+    if (denied)
+        return denied[1];
+    if (/ timed out after \d+ms$/.test(message))
+        return 'command_timeout';
+    return 'command_failed';
+}
+function failedResult(result) {
+    return isRecord(result) && (typeof result.error === 'string' || result.success === false);
+}
+/**
+ * 20 hex characters: the tool call id stays within 40 characters, the
+ * shortest provider limit (OpenAI), because later model turns replay it.
+ */
+function shortId() {
+    return (0, node_crypto_1.randomUUID)().replace(/-/g, '').slice(0, 20);
+}
+/**
+ * Runs a direct command without a model call. The tool goes through the
+ * same AI SDK wrapper as on the model path: input schema, the managed guard
+ * (manifest, principal, roles, revocation, budget), confirmation
+ * (`needsApproval` / the policy) and audit. A tool that needs confirmation
+ * answers with an AI SDK approval request; the approval continuation runs
+ * it. One content-free metric event per request: no model, unknown cost,
+ * the executed call (or none) as tool count.
+ */
+async function runDirectCommand(options) {
+    const { command, registry, managedTurn, turnMetrics } = options;
+    const nextId = options.generateId ?? shortId;
+    const name = resolveCommandToolName(registry, command.invocation.tool);
+    const toolName = name ?? (0, local_tool_bindings_js_1.modelFacingToolName)(command.invocation.tool);
+    const record = (calls, failures) => {
+        turnMetrics?.recordStep({
+            model: null,
+            inputTokens: 0,
+            outputTokens: 0,
+            cost: cost_js_1.UNKNOWN_TURN_COST,
+            toolNames: calls > 0 ? [toolName] : [],
+            failedToolNames: failures > 0 ? [toolName] : [],
+        });
+        turnMetrics?.finish({ status: 'completed', errorCode: null });
+    };
+    const stream = (0, ai_1.createUIMessageStream)({
+        onError: () => 'Command failed',
+        execute: async ({ writer }) => {
+            try {
+                writer.write({ type: 'start' });
+                if (command.settled) {
+                    writer.write({ type: 'finish' });
+                    record(0, 0);
+                    return;
+                }
+                const toolCallId = command.approval?.toolCallId ?? `${chat_command_js_1.CHAT_COMMAND_TOOL_CALL_PREFIX}${nextId()}`;
+                const fresh = command.approval === undefined;
+                if (fresh) {
+                    writer.write({ type: 'start-step' });
+                    writer.write({ type: 'tool-input-available', toolCallId, toolName, input: command.invocation.args });
+                }
+                const end = (calls, failures) => {
+                    if (fresh)
+                        writer.write({ type: 'finish-step' });
+                    writer.write({ type: 'finish' });
+                    record(calls, failures);
+                };
+                const fail = (errorText) => {
+                    writer.write({ type: 'tool-output-error', toolCallId, errorText });
+                    end(1, 1);
+                };
+                if (!name || !options.tools[name]) {
+                    fail('command_tool_unavailable');
+                    return;
+                }
+                const parsed = registry[name].inputSchema.safeParse(command.invocation.args);
+                if (!parsed.success) {
+                    fail('command_input_invalid');
+                    return;
+                }
+                if (command.approval && !command.approval.approved) {
+                    writer.write({ type: 'tool-output-denied', toolCallId });
+                    end(0, 0);
+                    return;
+                }
+                if (command.approval) {
+                    // The approval comes from the client's history: it runs only if
+                    // this server asked for exactly this call.
+                    const refuse = (code) => {
+                        writer.write({ type: 'tool-output-error', toolCallId, errorText: code });
+                        end(0, 0);
+                    };
+                    const verified = options.approvals?.verify({
+                        approvalId: command.approval.approvalId,
+                        toolCallId,
+                        toolName: name,
+                        input: command.invocation.args,
+                    });
+                    if (!verified?.ok) {
+                        refuse(verified?.code ?? 'approval_not_issued');
+                        return;
+                    }
+                    if (options.approvalStore) {
+                        try {
+                            if (!(await options.approvalStore.consume(verified.key, verified.expiresAtMs, { scope: options.approvalScope ?? '' }))) {
+                                refuse('approval_already_used');
+                                return;
+                            }
+                        }
+                        catch {
+                            refuse('approval_store_unavailable');
+                            return;
+                        }
+                    }
+                }
+                const tool = (0, engine_js_1.createAiSdkTools)({
+                    tools: { [name]: options.tools[name] },
+                    ...(managedTurn
+                        ? {
+                            beforeToolCall: managedTurn.beforeToolCall,
+                            afterToolCall: managedTurn.afterToolCall,
+                            onToolError: managedTurn.onToolError,
+                            resolveApproval: managedTurn.resolveApproval,
+                            toolTimeoutMs: managedTurn.toolTimeoutMs,
+                        }
+                        : {}),
+                })[name];
+                const executionOptions = { toolCallId, messages: [] };
+                if (fresh) {
+                    let needsApproval;
+                    try {
+                        needsApproval = typeof tool.needsApproval === 'function'
+                            ? Boolean(await tool.needsApproval(command.invocation.args, executionOptions))
+                            : tool.needsApproval === true;
+                    }
+                    catch (error) {
+                        fail(failureCode(error));
+                        return;
+                    }
+                    if (needsApproval) {
+                        if (!options.approvals) {
+                            writer.write({ type: 'tool-output-error', toolCallId, errorText: 'approval_binding_unavailable' });
+                            end(0, 0);
+                            return;
+                        }
+                        writer.write({
+                            type: 'tool-approval-request',
+                            approvalId: options.approvals.issue({ toolCallId, toolName: name, input: command.invocation.args }),
+                            toolCallId,
+                        });
+                        end(0, 0);
+                        return;
+                    }
+                }
+                let output;
+                try {
+                    // The wrapped tool parses the arguments itself and hands the tool
+                    // the schema output once; parsing them here first would parse twice.
+                    output = await tool.execute(command.invocation.args, executionOptions);
+                }
+                catch (error) {
+                    fail(failureCode(error));
+                    return;
+                }
+                writer.write({ type: 'tool-output-available', toolCallId, output });
+                end(1, failedResult(output) ? 1 : 0);
+            }
+            catch (error) {
+                turnMetrics?.finish({ status: 'error', errorCode: 'pipeline_error' });
+                options.onError?.(error);
+                throw error;
+            }
+        },
+    });
+    return (0, ai_1.createUIMessageStreamResponse)({ stream });
+}

package/dist/cjs/server/adapters/nextjs/index.d.ts

@@ -1,8 +1,16 @@
 export { withAiTool } from './with-ai-tool.js';
 export { createAiChatHandler, type StreamHandlerContext, type AiChatHandlerFullConfig, } from './create-ai-chat-handler.js';
-export { extractOrigin, buildRuntimeContext, buildToolContext, createInternalApiCallerFromRequest, } from './context-helpers.js';
+export { extractOrigin, buildRuntimeContext, buildToolContext, createInternalApiCallerFromRequest, type OriginOptions, } from './context-helpers.js';
 export { sanitizeModelMessages } from './sanitize-model-messages.js';
 export { prepareModelMessages, wrapToolsForVercelAi, type PrepareModelMessagesOptions, } from './prepare-model-messages.js';
 export { executeTool } from './server-action-helper.js';
+export { createHybridToolDiscovery, NON_DOMAIN_TOOL_NAMES, type HybridToolDiscovery, } from './tool-discovery.js';
+export { applyClarificationResume, resolveClarificationResume, type ClarificationResume, } from './clarification-resume.js';
+export { createChatInteractionsHandler, type ChatInteractionsHandlerConfig, } from './chat-interactions-handler.js';
+export { createRecordingTranscriptionHandler, DEFAULT_RECORDING_LANGUAGES, type RecordingTranscriptionHandlerConfig, } from './recording-transcription-handler.js';
+export type { ApprovalStore, ApprovalDenialCode } from './approval-binding.js';
+export { resolveDirectCommand, runDirectCommand, stripChatCommandMessages, type DirectCommandRequest, type RunDirectCommandOptions, } from './direct-command.js';
+export { formatChatCommandMessage, parseChatCommandMessage, type ChatCommandInvocation, } from '../../../contracts/chat-command.js';
+export { chatText, mergeChatInteractions, parseChatInteractionOverrides, parseChatInteractions, type ChatCommandData, type ChatEntityData, type ChatInteractionOverrides, type ChatInteractionsData, } from '../../../contracts/chat-interactions.js';
 export { createNextInternalApiCaller } from '../../core/index.js';
-export type { WithAiToolOptions, AiToolRouteHandler, AiChatHandlerConfig, LoadTools, GuardrailResult, GuardrailHook, IntentRoutingResult, IntentRouter, StepLimitSource, StepUsage, PipelineStepReport, PipelineStreamStatus, PipelineStreamState, ExecuteToolOptions, ExecuteToolResult, AiPipeline, FollowupsConfig, PipelineResult, } from './types.js';
+export type { WithAiToolOptions, AiToolRouteHandler, AiChatHandlerConfig, LoadTools, GuardrailResult, GuardrailHook, IntentRoutingResult, IntentRouter, StepLimitSource, StepUsage, PipelineStepReport, PipelineStreamStatus, PipelineStreamState, ExecuteToolOptions, ExecuteToolResult, AiPipeline, ClarificationConfig, PlanningConfig, FollowupsConfig, PipelineResult, ManagedLocalRuntimeConfig, ResolveTurnSnapshotContext, } from './types.js';

package/dist/cjs/server/adapters/nextjs/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNextInternalApiCaller = exports.executeTool = exports.wrapToolsForVercelAi = exports.prepareModelMessages = exports.sanitizeModelMessages = exports.createInternalApiCallerFromRequest = exports.buildToolContext = exports.buildRuntimeContext = exports.extractOrigin = exports.createAiChatHandler = exports.withAiTool = void 0;
+exports.createNextInternalApiCaller = exports.parseChatInteractions = exports.parseChatInteractionOverrides = exports.mergeChatInteractions = exports.chatText = exports.parseChatCommandMessage = exports.formatChatCommandMessage = exports.stripChatCommandMessages = exports.runDirectCommand = exports.resolveDirectCommand = exports.DEFAULT_RECORDING_LANGUAGES = exports.createRecordingTranscriptionHandler = exports.createChatInteractionsHandler = exports.resolveClarificationResume = exports.applyClarificationResume = exports.NON_DOMAIN_TOOL_NAMES = exports.createHybridToolDiscovery = exports.executeTool = exports.wrapToolsForVercelAi = exports.prepareModelMessages = exports.sanitizeModelMessages = exports.createInternalApiCallerFromRequest = exports.buildToolContext = exports.buildRuntimeContext = exports.extractOrigin = exports.createAiChatHandler = exports.withAiTool = void 0;
 var with_ai_tool_js_1 = require("./with-ai-tool.js");
 Object.defineProperty(exports, "withAiTool", { enumerable: true, get: function () { return with_ai_tool_js_1.withAiTool; } });
 var create_ai_chat_handler_js_1 = require("./create-ai-chat-handler.js");
@@ -17,6 +17,29 @@ Object.defineProperty(exports, "prepareModelMessages", { enumerable: true, get:
 Object.defineProperty(exports, "wrapToolsForVercelAi", { enumerable: true, get: function () { return prepare_model_messages_js_1.wrapToolsForVercelAi; } });
 var server_action_helper_js_1 = require("./server-action-helper.js");
 Object.defineProperty(exports, "executeTool", { enumerable: true, get: function () { return server_action_helper_js_1.executeTool; } });
+var tool_discovery_js_1 = require("./tool-discovery.js");
+Object.defineProperty(exports, "createHybridToolDiscovery", { enumerable: true, get: function () { return tool_discovery_js_1.createHybridToolDiscovery; } });
+Object.defineProperty(exports, "NON_DOMAIN_TOOL_NAMES", { enumerable: true, get: function () { return tool_discovery_js_1.NON_DOMAIN_TOOL_NAMES; } });
+var clarification_resume_js_1 = require("./clarification-resume.js");
+Object.defineProperty(exports, "applyClarificationResume", { enumerable: true, get: function () { return clarification_resume_js_1.applyClarificationResume; } });
+Object.defineProperty(exports, "resolveClarificationResume", { enumerable: true, get: function () { return clarification_resume_js_1.resolveClarificationResume; } });
+var chat_interactions_handler_js_1 = require("./chat-interactions-handler.js");
+Object.defineProperty(exports, "createChatInteractionsHandler", { enumerable: true, get: function () { return chat_interactions_handler_js_1.createChatInteractionsHandler; } });
+var recording_transcription_handler_js_1 = require("./recording-transcription-handler.js");
+Object.defineProperty(exports, "createRecordingTranscriptionHandler", { enumerable: true, get: function () { return recording_transcription_handler_js_1.createRecordingTranscriptionHandler; } });
+Object.defineProperty(exports, "DEFAULT_RECORDING_LANGUAGES", { enumerable: true, get: function () { return recording_transcription_handler_js_1.DEFAULT_RECORDING_LANGUAGES; } });
+var direct_command_js_1 = require("./direct-command.js");
+Object.defineProperty(exports, "resolveDirectCommand", { enumerable: true, get: function () { return direct_command_js_1.resolveDirectCommand; } });
+Object.defineProperty(exports, "runDirectCommand", { enumerable: true, get: function () { return direct_command_js_1.runDirectCommand; } });
+Object.defineProperty(exports, "stripChatCommandMessages", { enumerable: true, get: function () { return direct_command_js_1.stripChatCommandMessages; } });
+var chat_command_js_1 = require("../../../contracts/chat-command.js");
+Object.defineProperty(exports, "formatChatCommandMessage", { enumerable: true, get: function () { return chat_command_js_1.formatChatCommandMessage; } });
+Object.defineProperty(exports, "parseChatCommandMessage", { enumerable: true, get: function () { return chat_command_js_1.parseChatCommandMessage; } });
+var chat_interactions_js_1 = require("../../../contracts/chat-interactions.js");
+Object.defineProperty(exports, "chatText", { enumerable: true, get: function () { return chat_interactions_js_1.chatText; } });
+Object.defineProperty(exports, "mergeChatInteractions", { enumerable: true, get: function () { return chat_interactions_js_1.mergeChatInteractions; } });
+Object.defineProperty(exports, "parseChatInteractionOverrides", { enumerable: true, get: function () { return chat_interactions_js_1.parseChatInteractionOverrides; } });
+Object.defineProperty(exports, "parseChatInteractions", { enumerable: true, get: function () { return chat_interactions_js_1.parseChatInteractions; } });
 // Re-export from server-node for convenience
 var index_js_1 = require("../../core/index.js");
 Object.defineProperty(exports, "createNextInternalApiCaller", { enumerable: true, get: function () { return index_js_1.createNextInternalApiCaller; } });

package/dist/cjs/server/adapters/nextjs/prepare-model-messages.d.ts

@@ -10,6 +10,7 @@
  * @module
  */
 import { type UIMessage } from 'ai';
+import { type AiSdkToolHooks } from '../../../runtime/ai-sdk/engine.js';
 export interface PrepareModelMessagesOptions {
     /** Max model messages to keep after slicing (default: 12). */
     maxContextMessages?: number;
@@ -55,4 +56,4 @@ export declare function prepareModelMessages(uiMessages: UIMessage[], options?:
  * const result = streamText({ tools: vercelTools, ... });
  * ```
  */
-export declare function wrapToolsForVercelAi(sdkTools: Record<string, unknown>): Record<string, unknown>;
+export declare function wrapToolsForVercelAi(sdkTools: Record<string, unknown>, hooks?: AiSdkToolHooks): Record<string, unknown>;

package/dist/cjs/server/adapters/nextjs/prepare-model-messages.js

@@ -14,6 +14,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.prepareModelMessages = prepareModelMessages;
 exports.wrapToolsForVercelAi = wrapToolsForVercelAi;
 const ai_1 = require("ai");
+const engine_js_1 = require("../../../runtime/ai-sdk/engine.js");
 const sanitize_model_messages_js_1 = require("./sanitize-model-messages.js");
 /**
  * Convert UI messages into sanitized model messages ready for `streamText()`.
@@ -97,18 +98,9 @@ function isPlainObject(v) {
  * const result = streamText({ tools: vercelTools, ... });
  * ```
  */
-function wrapToolsForVercelAi(sdkTools) {
-    const wrapped = {};
-    for (const [name, raw] of Object.entries(sdkTools)) {
-        const sdkTool = raw;
-        wrapped[name] = (0, ai_1.tool)({
-            description: sdkTool.description,
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            inputSchema: (0, ai_1.zodSchema)(sdkTool.parameters),
-            needsApproval: sdkTool.needsApproval,
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            execute: sdkTool.execute,
-        });
-    }
-    return wrapped;
+function wrapToolsForVercelAi(sdkTools, hooks) {
+    return (0, engine_js_1.createAiSdkTools)({
+        tools: sdkTools,
+        ...hooks,
+    });
 }

package/dist/cjs/server/adapters/nextjs/recording-transcription-handler.d.ts

@@ -0,0 +1,31 @@
+/** The languages a recording may be transcribed in, unless the app sets its own list. */
+export declare const DEFAULT_RECORDING_LANGUAGES: readonly ["de", "en", "de-DE", "en-US", "en-GB", "fr", "es", "it", "nl", "pt"];
+export interface RecordingTranscriptionHandlerConfig {
+    /** The app's own session check; `false` answers 401 before the audio is read. */
+    authorize(request: Request): boolean | Promise<boolean>;
+    /** Base URL of a service with the common `POST /v1/audio/transcriptions` API (Parakeet, Whisper, …); unset answers 503. */
+    url: string | undefined;
+    /** Sent as `Bearer` token when set. */
+    apiKey?: string;
+    /** Default `parakeet-tdt-0.6b-v3`. */
+    model?: string;
+    /** Allowed `?language=` values; the first two letters go to the service. Default `DEFAULT_RECORDING_LANGUAGES`. */
+    languages?: readonly string[];
+    /** Used when the request names no language. Default `de`. */
+    defaultLanguage?: string;
+    /** Default 5 MB, more than two minutes of 16 kHz mono 16-bit audio. */
+    maxBytes?: number;
+    /** Default 45 seconds. */
+    timeoutMs?: number;
+    /** Receives the failure for the server log; the browser only learns that it failed. */
+    onError?: (error: unknown) => void;
+    fetch?: typeof globalThis.fetch;
+}
+/**
+ * A Next.js route handler for the `recording` speech input
+ * (`RecordedSttAdapter`, which posts `audio/wav` to `/api/ai/speech-recognize`).
+ * It checks the app's session, the format, language and size, and forwards the
+ * recording to the app's own transcription service, whose address, key and
+ * model stay on the server.
+ */
+export declare function createRecordingTranscriptionHandler(config: RecordingTranscriptionHandlerConfig): (request: Request) => Promise<Response>;

package/dist/cjs/server/adapters/nextjs/recording-transcription-handler.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_RECORDING_LANGUAGES = void 0;
+exports.createRecordingTranscriptionHandler = createRecordingTranscriptionHandler;
+const url_js_1 = require("../../../contracts/url.js");
+/** The languages a recording may be transcribed in, unless the app sets its own list. */
+exports.DEFAULT_RECORDING_LANGUAGES = ['de', 'en', 'de-DE', 'en-US', 'en-GB', 'fr', 'es', 'it', 'nl', 'pt'];
+const failed = (status, error) => Response.json({ error }, { status });
+/**
+ * A Next.js route handler for the `recording` speech input
+ * (`RecordedSttAdapter`, which posts `audio/wav` to `/api/ai/speech-recognize`).
+ * It checks the app's session, the format, language and size, and forwards the
+ * recording to the app's own transcription service, whose address, key and
+ * model stay on the server.
+ */
+function createRecordingTranscriptionHandler(config) {
+    const languages = config.languages ?? exports.DEFAULT_RECORDING_LANGUAGES;
+    const maxBytes = config.maxBytes ?? 5 * 1024 * 1024;
+    const timeoutMs = config.timeoutMs ?? 45_000;
+    const onError = config.onError
+        ?? ((error) => console.error('[speech] Recording transcription failed:', error instanceof Error ? error.message : 'unknown error'));
+    return async function POST(request) {
+        if (!(await config.authorize(request)))
+            return failed(401, 'Authentication required');
+        if (!config.url)
+            return failed(503, 'Speech service not configured');
+        if (!request.headers.get('content-type')?.startsWith('audio/wav'))
+            return failed(415, 'Unsupported audio format');
+        const language = new URL(request.url).searchParams.get('language') || config.defaultLanguage || 'de';
+        if (!languages.includes(language))
+            return failed(400, 'Unsupported language');
+        const audio = await request.arrayBuffer();
+        if (audio.byteLength === 0)
+            return failed(400, 'Empty recording');
+        if (audio.byteLength > maxBytes)
+            return failed(413, 'Recording too long');
+        const form = new FormData();
+        form.set('file', new File([audio], 'recording.wav', { type: 'audio/wav' }));
+        form.set('model', config.model || 'parakeet-tdt-0.6b-v3');
+        form.set('language', language.slice(0, 2));
+        try {
+            const response = await (config.fetch ?? globalThis.fetch)(`${(0, url_js_1.trimTrailingSlashes)(config.url)}/v1/audio/transcriptions`, {
+                method: 'POST',
+                headers: config.apiKey ? { authorization: `Bearer ${config.apiKey}` } : {},
+                body: form,
+                signal: AbortSignal.timeout(timeoutMs),
+            });
+            if (!response.ok)
+                throw new Error(`transcription service answered ${response.status}`);
+            const result = (await response.json());
+            return Response.json({ text: typeof result.text === 'string' ? result.text.trim() : '' });
+        }
+        catch (error) {
+            onError(error);
+            return failed(502, 'Transcription failed');
+        }
+    };
+}

package/dist/cjs/server/adapters/nextjs/request-guards.d.ts

@@ -0,0 +1,41 @@
+/** Default cap on the request body of the chat handler: 1 MB. */
+export declare const DEFAULT_MAX_BODY_BYTES = 1000000;
+export interface RequestGuardOptions {
+    /** Origins besides the request's own that may post from a browser. */
+    allowedOrigins?: ReadonlyArray<string>;
+    /** `false` turns the browser cross-origin check off. Default: on. */
+    crossOriginProtection?: boolean;
+}
+/**
+ * Refuses a request a browser sent for another site, and a body that is not
+ * JSON.
+ *
+ * The chat route authenticates with the user's cookie, and a page on another
+ * site (also another subdomain of the same site) can make the browser post to
+ * it with that cookie. A `text/plain` form post needs no CORS preflight, so
+ * the content type must be JSON, which a cross-origin page cannot send
+ * without a preflight; and a browser cross-origin request is refused:
+ *
+ * - `Origin: null` (a sandboxed or opaque origin) is always refused.
+ * - `Sec-Fetch-Site`, when present, must be `same-origin` (or `none`, a
+ *   navigation by the user); `same-site` and `cross-site` pass only with an
+ *   `Origin` listed in `allowedOrigins`.
+ * - Otherwise `Origin`, when present, must be the request's own origin (the
+ *   request URL's, the Host header's, or the first forwarded host and
+ *   protocol, see `publicOrigins`) or one of `allowedOrigins`.
+ * - A request with neither header is not from a browser (server to server).
+ */
+export declare function checkRequestHeaders(req: Request, options?: RequestGuardOptions): Response | undefined;
+/**
+ * Reads the JSON body, or answers 413 once it exceeds `maxBytes` and 400
+ * (`invalid_json`) when it does not parse. The declared
+ * `Content-Length` is checked before the body is read, and the bytes actually
+ * read are counted, because the header may be absent (chunked) or wrong.
+ */
+export declare function readJsonBody(req: Request, maxBytes?: number): Promise<{
+    ok: true;
+    value: unknown;
+} | {
+    ok: false;
+    response: Response;
+}>;