glirastes 0.2.1 → 0.3.1

package/dist/cjs/server/adapters/nextjs/filter-fallback-error.d.ts

@@ -0,0 +1,11 @@
+type ErrorChunk = {
+    type: 'error';
+    errorText: string;
+};
+declare function isErrorChunk(chunk: unknown): chunk is ErrorChunk;
+export declare function filterFallbackError<T>(source: ReadableStream<T>): ReadableStream<T>;
+export declare const __testing__: {
+    FALLBACK_ERROR_TEXT: string;
+    isErrorChunk: typeof isErrorChunk;
+};
+export {};

package/dist/cjs/server/adapters/nextjs/filter-fallback-error.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__testing__ = void 0;
+exports.filterFallbackError = filterFallbackError;
+/**
+ * The Vercel AI SDK emits a generic
+ *   { type: 'error', errorText: 'No output generated. Check the stream for errors.' }
+ * chunk whenever `streamText` finishes with no text output — including the
+ * (very common) case where it already streamed a real error chunk earlier
+ * in the same response (e.g. an upstream provider rejection).
+ *
+ * That double-error confuses chat UIs: the first message says "API key
+ * invalid", the second says "no output, check the stream for errors", and
+ * users have no way to tell they describe the same incident.
+ *
+ * This transform drops the fallback error iff a more specific error chunk
+ * has already been forwarded in the same stream. The first error always
+ * passes through unchanged.
+ */
+const FALLBACK_ERROR_TEXT = 'No output generated. Check the stream for errors.';
+function isErrorChunk(chunk) {
+    return (typeof chunk === 'object' &&
+        chunk !== null &&
+        chunk.type === 'error' &&
+        typeof chunk.errorText === 'string');
+}
+function filterFallbackError(source) {
+    let seenError = false;
+    return source.pipeThrough(new TransformStream({
+        transform(chunk, controller) {
+            if (isErrorChunk(chunk)) {
+                if (seenError && chunk.errorText === FALLBACK_ERROR_TEXT) {
+                    return; // drop the duplicate fallback
+                }
+                seenError = true;
+            }
+            controller.enqueue(chunk);
+        },
+    }));
+}
+exports.__testing__ = { FALLBACK_ERROR_TEXT, isErrorChunk };

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

@@ -0,0 +1,8 @@
+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 { sanitizeModelMessages } from './sanitize-model-messages.js';
+export { prepareModelMessages, wrapToolsForVercelAi, type PrepareModelMessagesOptions, } from './prepare-model-messages.js';
+export { executeTool } from './server-action-helper.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';

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

@@ -0,0 +1,22 @@
+"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;
+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");
+Object.defineProperty(exports, "createAiChatHandler", { enumerable: true, get: function () { return create_ai_chat_handler_js_1.createAiChatHandler; } });
+var context_helpers_js_1 = require("./context-helpers.js");
+Object.defineProperty(exports, "extractOrigin", { enumerable: true, get: function () { return context_helpers_js_1.extractOrigin; } });
+Object.defineProperty(exports, "buildRuntimeContext", { enumerable: true, get: function () { return context_helpers_js_1.buildRuntimeContext; } });
+Object.defineProperty(exports, "buildToolContext", { enumerable: true, get: function () { return context_helpers_js_1.buildToolContext; } });
+Object.defineProperty(exports, "createInternalApiCallerFromRequest", { enumerable: true, get: function () { return context_helpers_js_1.createInternalApiCallerFromRequest; } });
+var sanitize_model_messages_js_1 = require("./sanitize-model-messages.js");
+Object.defineProperty(exports, "sanitizeModelMessages", { enumerable: true, get: function () { return sanitize_model_messages_js_1.sanitizeModelMessages; } });
+var prepare_model_messages_js_1 = require("./prepare-model-messages.js");
+Object.defineProperty(exports, "prepareModelMessages", { enumerable: true, get: function () { return prepare_model_messages_js_1.prepareModelMessages; } });
+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; } });
+// 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

@@ -0,0 +1,58 @@
+/**
+ * Utilities for preparing model messages and wrapping tools for Vercel AI SDK.
+ *
+ * - {@link prepareModelMessages} encapsulates the full pipeline:
+ *   `convertToModelMessages` → `slice` → `pruneMessages` → `sanitizeModelMessages`
+ *
+ * - {@link wrapToolsForVercelAi} converts SDK tools (from `toolsToAiTools`) into
+ *   Vercel AI SDK `tool()` instances ready for `streamText()`.
+ *
+ * @module
+ */
+import { type UIMessage } from 'ai';
+export interface PrepareModelMessagesOptions {
+    /** Max model messages to keep after slicing (default: 12). */
+    maxContextMessages?: number;
+    /** Override pruneMessages config. */
+    pruneConfig?: {
+        /** How to handle reasoning blocks (default: 'none'). */
+        reasoning?: 'none' | 'keep';
+        /** Tool-call pruning strategy (default: 'before-last-3-messages'). */
+        toolCalls?: string;
+        /** Empty message handling (default: 'remove'). */
+        emptyMessages?: 'remove' | 'keep';
+    };
+}
+/**
+ * Convert UI messages into sanitized model messages ready for `streamText()`.
+ *
+ * Pipeline:
+ * 1. `convertToModelMessages` (with `ignoreIncompleteToolCalls: true`)
+ * 2. Slice to `maxContextMessages`
+ * 3. `pruneMessages` — remove old reasoning / tool-calls / empty messages
+ * 4. `sanitizeModelMessages` — strip orphaned tool-calls for OpenAI compatibility
+ *
+ * @example
+ * ```ts
+ * import { prepareModelMessages } from './index.js';
+ *
+ * const messages = await prepareModelMessages(uiMessages, {
+ *   maxContextMessages: 12,
+ * });
+ * // messages is safe to pass to streamText()
+ * ```
+ */
+export declare function prepareModelMessages(uiMessages: UIMessage[], options?: PrepareModelMessagesOptions): Promise<unknown[]>;
+/**
+ * Convert SDK AI tools (output of `toolsToAiTools`) into Vercel AI SDK
+ * `tool()` instances.
+ *
+ * @example
+ * ```ts
+ * import { wrapToolsForVercelAi } from './index.js';
+ *
+ * const vercelTools = wrapToolsForVercelAi(ctx.tools);
+ * const result = streamText({ tools: vercelTools, ... });
+ * ```
+ */
+export declare function wrapToolsForVercelAi(sdkTools: Record<string, unknown>): Record<string, unknown>;

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

@@ -0,0 +1,114 @@
+"use strict";
+/**
+ * Utilities for preparing model messages and wrapping tools for Vercel AI SDK.
+ *
+ * - {@link prepareModelMessages} encapsulates the full pipeline:
+ *   `convertToModelMessages` → `slice` → `pruneMessages` → `sanitizeModelMessages`
+ *
+ * - {@link wrapToolsForVercelAi} converts SDK tools (from `toolsToAiTools`) into
+ *   Vercel AI SDK `tool()` instances ready for `streamText()`.
+ *
+ * @module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareModelMessages = prepareModelMessages;
+exports.wrapToolsForVercelAi = wrapToolsForVercelAi;
+const ai_1 = require("ai");
+const sanitize_model_messages_js_1 = require("./sanitize-model-messages.js");
+/**
+ * Convert UI messages into sanitized model messages ready for `streamText()`.
+ *
+ * Pipeline:
+ * 1. `convertToModelMessages` (with `ignoreIncompleteToolCalls: true`)
+ * 2. Slice to `maxContextMessages`
+ * 3. `pruneMessages` — remove old reasoning / tool-calls / empty messages
+ * 4. `sanitizeModelMessages` — strip orphaned tool-calls for OpenAI compatibility
+ *
+ * @example
+ * ```ts
+ * import { prepareModelMessages } from './index.js';
+ *
+ * const messages = await prepareModelMessages(uiMessages, {
+ *   maxContextMessages: 12,
+ * });
+ * // messages is safe to pass to streamText()
+ * ```
+ */
+async function prepareModelMessages(uiMessages, options) {
+    const maxCtx = options?.maxContextMessages ?? 12;
+    const raw = await (0, ai_1.convertToModelMessages)(uiMessages, {
+        ignoreIncompleteToolCalls: true,
+    });
+    const sliced = raw.slice(-maxCtx);
+    const pruned = (0, ai_1.pruneMessages)({
+        messages: sliced,
+        reasoning: (options?.pruneConfig?.reasoning ?? 'none'),
+        toolCalls: (options?.pruneConfig?.toolCalls ??
+            'before-last-3-messages'),
+        emptyMessages: (options?.pruneConfig?.emptyMessages ?? 'remove'),
+    });
+    const sanitized = (0, sanitize_model_messages_js_1.sanitizeModelMessages)(pruned);
+    // Strip uiAction from tool-result parts — the LLM doesn't need them
+    // (uiActions are auto-generated by SDK templates and consumed by the client)
+    return stripUiActionsFromToolResults(sanitized);
+}
+// ---------------------------------------------------------------------------
+// stripUiActionsFromToolResults
+// ---------------------------------------------------------------------------
+/**
+ * Remove `uiAction` fields from tool-result parts in model messages.
+ *
+ * UI actions are auto-generated by SDK templates (uiActionOnSuccess, uiPattern)
+ * and consumed by the client for toasts, navigation, and refreshes. The LLM
+ * doesn't generate or use them — keeping them wastes 100-500 tokens per call.
+ *
+ * This runs AFTER sanitization so it doesn't interfere with orphan detection.
+ */
+function stripUiActionsFromToolResults(messages) {
+    return messages.map((msg) => {
+        const m = msg;
+        if (m.role !== 'tool' || !Array.isArray(m.content))
+            return msg;
+        const newContent = m.content.map((part) => {
+            if (part.type !== 'tool-result' || !isPlainObject(part.result)) {
+                return part;
+            }
+            const result = part.result;
+            if (!('uiAction' in result))
+                return part;
+            const { uiAction: _stripped, ...rest } = result;
+            return { ...part, result: rest };
+        });
+        return { ...m, content: newContent };
+    });
+}
+function isPlainObject(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+/**
+ * Convert SDK AI tools (output of `toolsToAiTools`) into Vercel AI SDK
+ * `tool()` instances.
+ *
+ * @example
+ * ```ts
+ * import { wrapToolsForVercelAi } from './index.js';
+ *
+ * const vercelTools = wrapToolsForVercelAi(ctx.tools);
+ * 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;
+}

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

@@ -0,0 +1,64 @@
+/**
+ * Sanitize model messages for OpenAI compatibility.
+ *
+ * Handles three classes of problems that occur after convertToModelMessages +
+ * pruneMessages from the Vercel AI SDK:
+ *
+ * 1. **Orphaned tool-calls** — assistant has tool-call but no matching
+ *    tool-result anywhere (pruneMessages stripped it).
+ * 2. **Orphaned tool-approval-requests** — approval request without matching
+ *    response, or whose linked tool-call was removed.
+ * 3. **Ordering violations** — OpenAI requires tool-result messages to
+ *    IMMEDIATELY follow their assistant message. After pruning, the ordering
+ *    can break.
+ *
+ * **Important:** The OpenAI provider silently drops `tool-approval-response`
+ * parts during serialization. A tool message containing ONLY approval-responses
+ * (no tool-result) produces zero OpenAI messages. Therefore, a tool-call is
+ * only considered "safe" when it has an adjacent `tool-result` — a
+ * `tool-approval-response` alone does NOT satisfy this requirement.
+ *
+ * **Exception:** When the LAST message is a tool message containing
+ * `tool-approval-response` parts, those tool-calls are preserved. The Vercel
+ * AI SDK's `streamText` runs `collectToolApprovals()` on the last message
+ * and executes approved tools BEFORE sending anything to OpenAI. Stripping
+ * these would break the approval flow (causing an infinite loop where the
+ * model re-generates the same tool call).
+ *
+ * The public API is {@link sanitizeModelMessages}, which runs two passes:
+ * - Primary pass: adjacency-based orphan removal
+ * - Safety-net pass: strict re-check for any remaining orphans
+ *
+ * @module
+ */
+/**
+ * Sanitize model messages by removing orphaned tool-calls and
+ * tool-approval-requests.
+ *
+ * A tool-call is considered orphaned when it does not have an adjacent
+ * `tool-result` in the immediately following tool message(s). A
+ * `tool-approval-response` alone does NOT count — the OpenAI provider
+ * silently drops these during serialization.
+ *
+ * **Exception:** Tool-calls with a `tool-approval-response` in the LAST
+ * message are preserved. The Vercel AI SDK's `streamText` runs
+ * `collectToolApprovals()` to execute approved tools before calling the
+ * model provider, so these are safe to keep.
+ *
+ * Call this on the output of `pruneMessages()` (from the `ai` SDK) before
+ * passing messages to `streamText()`. Or use {@link prepareModelMessages}
+ * which calls this automatically.
+ *
+ * @example
+ * ```ts
+ * import { sanitizeModelMessages } from './index.js';
+ *
+ * const raw = await convertToModelMessages(uiMessages, {
+ *   ignoreIncompleteToolCalls: true,
+ * });
+ * const pruned = pruneMessages({ messages: raw.slice(-12), ... });
+ * const clean = sanitizeModelMessages(pruned);
+ * // clean is safe to pass to streamText()
+ * ```
+ */
+export declare function sanitizeModelMessages<T>(messages: T[]): T[];