glirastes 0.4.0 → 0.5.0

package/dist/cjs/server/adapters/nextjs/chat-interactions-handler.d.ts

@@ -0,0 +1,26 @@
+import { type ChatInteractionsData } from '../../../contracts/chat-interactions.js';
+import type { ManagedLocalRuntimeConfig } from './types.js';
+export interface ChatInteractionsHandlerConfig {
+    /** `chatInteractions` of the generated module. */
+    interactions: ChatInteractionsData;
+    /** Parsed `.glirastes/chat-interactions.json`; validated at creation. */
+    overrides?: unknown;
+    /**
+     * The chat handler's managed runtime. With it, the response is per user:
+     * commands, actions and searches whose tool this user may not run (Platform
+     * disabled, roles, revocation, not deployed) are left out.
+     */
+    managedRuntime?: ManagedLocalRuntimeConfig;
+}
+/**
+ * GET handler that serves the chat's `@` entities and `/` commands to the
+ * browser (`useChatInteractionsData`, `<glirastes-chat interactions>`).
+ * Overrides are applied once at creation; an invalid override file throws
+ * there, like an invalid policy. Nothing is sent to the Glirastes Platform.
+ *
+ * ```ts
+ * import overrides from '../../../.glirastes/chat-interactions.json' with { type: 'json' };
+ * export const GET = createChatInteractionsHandler({ interactions: generated.chatInteractions, overrides, managedRuntime });
+ * ```
+ */
+export declare function createChatInteractionsHandler(config: ChatInteractionsHandlerConfig): (request: Request) => Promise<Response>;

package/dist/cjs/server/adapters/nextjs/chat-interactions-handler.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createChatInteractionsHandler = createChatInteractionsHandler;
+const node_crypto_1 = require("node:crypto");
+const chat_interactions_js_1 = require("../../../contracts/chat-interactions.js");
+const index_js_1 = require("../../../contracts/index.js");
+const authorization_js_1 = require("../../../runtime/authorization.js");
+const local_tool_bindings_js_1 = require("../../../runtime/local-tool-bindings.js");
+const turn_snapshot_js_1 = require("../../../runtime/turn-snapshot.js");
+const HEADERS = { 'content-type': 'application/json', 'cache-control': 'private, no-store' };
+function json(body, status = 200) {
+    return new Response(JSON.stringify(body), { status, headers: HEADERS });
+}
+/**
+ * GET handler that serves the chat's `@` entities and `/` commands to the
+ * browser (`useChatInteractionsData`, `<glirastes-chat interactions>`).
+ * Overrides are applied once at creation; an invalid override file throws
+ * there, like an invalid policy. Nothing is sent to the Glirastes Platform.
+ *
+ * ```ts
+ * import overrides from '../../../.glirastes/chat-interactions.json' with { type: 'json' };
+ * export const GET = createChatInteractionsHandler({ interactions: generated.chatInteractions, overrides, managedRuntime });
+ * ```
+ */
+function createChatInteractionsHandler(config) {
+    const merged = (0, chat_interactions_js_1.mergeChatInteractions)((0, chat_interactions_js_1.parseChatInteractions)(config.interactions), config.overrides === undefined ? undefined : (0, chat_interactions_js_1.parseChatInteractionOverrides)(config.overrides));
+    return async function chatInteractionsHandler(request) {
+        const runtime = config.managedRuntime;
+        if (!runtime)
+            return json(merged);
+        const principal = index_js_1.PrincipalSchema.safeParse(await runtime.resolvePrincipal(request));
+        if (!principal.success)
+            return json({ error: 'Unauthorized' }, 401);
+        let snapshot;
+        try {
+            snapshot = await runtime.resolveTurnSnapshot({
+                request, turnId: `interactions-${(0, node_crypto_1.randomUUID)()}`, principal: principal.data,
+            });
+        }
+        catch {
+            return json({ error: 'Chat interactions unavailable' }, 503);
+        }
+        const revocations = await runtime.loadRevocations?.({ request, snapshot }) ?? [];
+        const allowed = (tool) => {
+            const manifestTool = snapshot.manifestRevision.tools.find((candidate) => (candidate.name === tool || (0, local_tool_bindings_js_1.modelFacingToolName)(candidate.name) === (0, local_tool_bindings_js_1.modelFacingToolName)(tool)));
+            if (!manifestTool || (0, turn_snapshot_js_1.isToolRevoked)(snapshot, manifestTool.toolId, revocations))
+                return false;
+            return (0, authorization_js_1.authorizeToolCall)({
+                principal: principal.data,
+                agentRevision: snapshot.agentRevision,
+                manifestRevision: snapshot.manifestRevision,
+                policyRevision: snapshot.policyRevision,
+                toolId: manifestTool.toolId,
+            }).allowed;
+        };
+        const entities = merged.entities.flatMap((entity) => {
+            const actions = (entity.actions ?? []).filter((action) => allowed(action.run.tool));
+            const search = entity.search && allowed(entity.search.tool) ? entity.search : undefined;
+            if (!search && actions.length === 0)
+                return [];
+            const { search: _search, actions: _actions, ...rest } = entity;
+            return [{ ...rest, ...(search ? { search } : {}), ...(actions.length > 0 ? { actions } : {}) }];
+        });
+        const commands = merged.commands.filter((command) => command.run.kind === 'prompt' || allowed(command.run.tool));
+        return json({ schemaVersion: 1, entities, commands });
+    };
+}

package/dist/cjs/server/adapters/nextjs/clarification-resume.d.ts

@@ -0,0 +1,21 @@
+/**
+ * A clarification answer joined with the request it completes. The original
+ * request stays in the client session; this only shapes routing input and
+ * the model-facing copy of the latest user message.
+ */
+export interface ClarificationResume {
+    readonly originalRequest: string;
+    readonly question: string;
+    readonly answer: string;
+    readonly optionId?: string;
+    /** Input for intent routing: no extra planner model call is needed. */
+    readonly routingText: string;
+    /** Replaces the latest user text for the model only. */
+    readonly modelText: string;
+    /** Index of the latest user message in the request's message array. */
+    readonly answerMessageIndex: number;
+}
+/** Resolves the latest user message as a clarification answer, if it is one. */
+export declare function resolveClarificationResume(messages: ReadonlyArray<unknown>): ClarificationResume | undefined;
+/** Returns a copy whose latest user message carries the model-facing resume text. */
+export declare function applyClarificationResume(messages: ReadonlyArray<unknown>, resume: ClarificationResume): unknown[];

package/dist/cjs/server/adapters/nextjs/clarification-resume.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveClarificationResume = resolveClarificationResume;
+exports.applyClarificationResume = applyClarificationResume;
+const clarification_js_1 = require("../../../contracts/clarification.js");
+const MAX_CHAIN_DEPTH = 3;
+const MAX_ORIGINAL_LENGTH = 2_000;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function messageText(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');
+}
+function clarificationQuestion(message, toolCallId) {
+    if (message.role !== 'assistant' || !Array.isArray(message.parts))
+        return undefined;
+    for (const part of message.parts) {
+        if (!isRecord(part) || part.toolCallId !== toolCallId)
+            continue;
+        const isClarification = part.type === `tool-${clarification_js_1.CLARIFICATION_TOOL_NAME}`
+            || (part.type === 'dynamic-tool' && part.toolName === clarification_js_1.CLARIFICATION_TOOL_NAME);
+        if (!isClarification || !isRecord(part.input))
+            continue;
+        const question = part.input.question;
+        if (typeof question === 'string' && question.trim())
+            return question.trim();
+    }
+    return undefined;
+}
+function resolveAt(messages, userIndex, depth) {
+    const latest = messages[userIndex];
+    if (!isRecord(latest) || latest.role !== 'user')
+        return undefined;
+    const parsed = (0, clarification_js_1.parseClarificationAnswer)(messageText(latest));
+    if (!parsed)
+        return undefined;
+    let assistantIndex = -1;
+    let question;
+    for (let index = userIndex - 1; index >= 0; index -= 1) {
+        const candidate = messages[index];
+        if (!isRecord(candidate))
+            continue;
+        question = clarificationQuestion(candidate, parsed.reference.toolCallId);
+        if (question) {
+            assistantIndex = index;
+            break;
+        }
+    }
+    if (!question || assistantIndex < 0)
+        return undefined;
+    let originalIndex = -1;
+    for (let index = assistantIndex - 1; index >= 0; index -= 1) {
+        const candidate = messages[index];
+        if (isRecord(candidate) && candidate.role === 'user') {
+            originalIndex = index;
+            break;
+        }
+    }
+    if (originalIndex < 0)
+        return undefined;
+    const earlier = depth < MAX_CHAIN_DEPTH
+        ? resolveAt(messages, originalIndex, depth + 1)
+        : undefined;
+    const originalRequest = (earlier?.routingText
+        ?? (0, clarification_js_1.stripClarificationMarkers)(messageText(messages[originalIndex])).trim())
+        .slice(0, MAX_ORIGINAL_LENGTH);
+    if (!originalRequest)
+        return undefined;
+    return {
+        originalRequest,
+        question,
+        answer: parsed.answer,
+        ...(parsed.reference.optionId ? { optionId: parsed.reference.optionId } : {}),
+        routingText: `${originalRequest}\n${question} ${parsed.answer}`,
+        modelText: [
+            `Original request: ${originalRequest}`,
+            `Clarification question: ${question}`,
+            `Answer: ${parsed.answer}`,
+            'Continue the original request with this answer.',
+        ].join('\n'),
+        answerMessageIndex: userIndex,
+    };
+}
+/** Resolves the latest user message as a clarification answer, if it is one. */
+function resolveClarificationResume(messages) {
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const candidate = messages[index];
+        if (isRecord(candidate) && candidate.role === 'user') {
+            return resolveAt(messages, index, 1);
+        }
+    }
+    return undefined;
+}
+/** Returns a copy whose latest user message carries the model-facing resume text. */
+function applyClarificationResume(messages, resume) {
+    return messages.map((message, index) => {
+        if (index !== resume.answerMessageIndex || !isRecord(message))
+            return message;
+        if (Array.isArray(message.parts)) {
+            const others = message.parts.filter((part) => !(isRecord(part) && part.type === 'text'));
+            return { ...message, parts: [{ type: 'text', text: resume.modelText }, ...others] };
+        }
+        return { ...message, content: resume.modelText };
+    });
+}

package/dist/cjs/server/adapters/nextjs/context-helpers.d.ts

@@ -1,22 +1,63 @@
 import type { ToolContext, RuntimeContext } from '../../../types.js';
 import { type InternalApiCaller, type NextInternalApiCallerOptions } from '../../core/index.js';
+export interface OriginOptions {
+    /**
+     * Take the origin from `x-forwarded-host` / `x-forwarded-proto` (their
+     * last value, the one the proxy nearest to the app set). Only for an app
+     * that is reachable solely through a proxy that sets or appends these
+     * headers: anyone who can reach the app directly can name any host in
+     * them, and endpoint tools send the user's cookie to that host. Default
+     * `false`: the origin of the request URL.
+     */
+    trustForwardedHeaders?: boolean;
+}
 /**
- * Extract origin from a Next.js request.
- * Checks x-forwarded-host/host headers, falls back to req.url.
+ * The origin the app calls itself on, for the default endpoint caller and
+ * `runtime.origin`.
+ *
+ * By default this is the origin of the request URL. Next.js builds it from
+ * the address the server listens on (or from the Host header only with
+ * `experimental.trustHostHeader`, which Vercel sets), never from a header
+ * the client chose. `Host` and `x-forwarded-host` are not read: a client that
+ * reaches the app without a proxy that overwrites them would make the app
+ * send the user's cookie to a host of its choice. With
+ * `trustForwardedHeaders` the last forwarded value is used; a value that is
+ * not a plain host falls back to the request URL.
  */
-export declare function extractOrigin(req: Request): string;
+export declare function extractOrigin(req: Request, options?: OriginOptions): string;
+/**
+ * The origins a browser on the app's public address may send as `Origin`,
+ * for the cross-origin check only, never for the endpoint caller: the
+ * request URL's origin, the Host header with `https` and with `http`, and
+ * the first forwarded host and protocol (what the outermost proxy saw).
+ *
+ * Both schemes for Host, because behind a TLS-terminating proxy the request
+ * URL says `http` while the browser's Origin says `https`. This does not
+ * widen what a cross-origin page can do: the browser sets `Host` itself to
+ * the host it sends the request to, a page cannot choose it (it is a
+ * forbidden header), and `x-forwarded-*` would need a CORS preflight, which
+ * the JSON content type needs anyway. A request whose Origin matches the
+ * Host was therefore sent by a page of that very host; a client that sets
+ * these headers itself is not a browser and carries no victim's cookie. The
+ * one thing added is the plain-http page of the same host, which only a
+ * network attacker could serve, and only where the host is reachable over
+ * http without HSTS. The check consults these origins only for a browser
+ * that sends no `Sec-Fetch-Site`.
+ */
+export declare function publicOrigins(req: Request): string[];
 /**
  * Build a RuntimeContext from a Next.js request.
  */
-export declare function buildRuntimeContext(req: Request): RuntimeContext;
+export declare function buildRuntimeContext(req: Request, options?: OriginOptions): RuntimeContext;
 /**
  * Build a complete ToolContext from a Next.js request.
  */
 export declare function buildToolContext(req: Request, options?: {
     locale?: string;
-}): ToolContext;
+} & OriginOptions): ToolContext;
 /**
- * Create an InternalApiCaller from a Next.js request.
- * Automatically extracts origin and cookies.
+ * Create an InternalApiCaller from a Next.js request: calls go to
+ * `overrides.origin` when given, else to `extractOrigin(req, overrides)`, and
+ * carry the request's cookie.
  */
-export declare function createInternalApiCallerFromRequest(req: Request, overrides?: Partial<NextInternalApiCallerOptions>): InternalApiCaller;
+export declare function createInternalApiCallerFromRequest(req: Request, overrides?: Partial<NextInternalApiCallerOptions> & OriginOptions): InternalApiCaller;

package/dist/cjs/server/adapters/nextjs/context-helpers.js

@@ -1,39 +1,92 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractOrigin = extractOrigin;
+exports.publicOrigins = publicOrigins;
 exports.buildRuntimeContext = buildRuntimeContext;
 exports.buildToolContext = buildToolContext;
 exports.createInternalApiCallerFromRequest = createInternalApiCallerFromRequest;
 const index_js_1 = require("../../core/index.js");
 /**
- * Extract origin from a Next.js request.
- * Checks x-forwarded-host/host headers, falls back to req.url.
+ * The origin the app calls itself on, for the default endpoint caller and
+ * `runtime.origin`.
+ *
+ * By default this is the origin of the request URL. Next.js builds it from
+ * the address the server listens on (or from the Host header only with
+ * `experimental.trustHostHeader`, which Vercel sets), never from a header
+ * the client chose. `Host` and `x-forwarded-host` are not read: a client that
+ * reaches the app without a proxy that overwrites them would make the app
+ * send the user's cookie to a host of its choice. With
+ * `trustForwardedHeaders` the last forwarded value is used; a value that is
+ * not a plain host falls back to the request URL.
  */
-function extractOrigin(req) {
-    const forwardedHost = req.headers.get('x-forwarded-host');
-    const forwardedProto = req.headers.get('x-forwarded-proto') ?? 'https';
-    if (forwardedHost) {
-        return `${forwardedProto}://${forwardedHost}`;
-    }
-    const host = req.headers.get('host');
-    if (host) {
-        const proto = host.startsWith('localhost') ? 'http' : 'https';
-        return `${proto}://${host}`;
+function extractOrigin(req, options = {}) {
+    const own = requestUrlOrigin(req);
+    if (options.trustForwardedHeaders) {
+        const host = lastForwardedValue(req.headers.get('x-forwarded-host'));
+        const proto = lastForwardedValue(req.headers.get('x-forwarded-proto')) ?? new URL(own).protocol.replace(':', '');
+        if (host && (proto === 'http' || proto === 'https')) {
+            try {
+                const url = new URL(`${proto}://${host}`);
+                if (url.host === host.toLowerCase() && url.pathname === '/' && !url.username && !url.password)
+                    return url.origin;
+            }
+            catch {
+                // Not a host: use the request URL.
+            }
+        }
     }
+    return own;
+}
+function requestUrlOrigin(req) {
     try {
-        const url = new URL(req.url);
-        return url.origin;
+        return new URL(req.url).origin;
     }
     catch {
         return 'http://localhost:3000';
     }
 }
+function lastForwardedValue(value) {
+    const last = value?.split(',').at(-1)?.trim();
+    return last ? last : undefined;
+}
+/**
+ * The origins a browser on the app's public address may send as `Origin`,
+ * for the cross-origin check only, never for the endpoint caller: the
+ * request URL's origin, the Host header with `https` and with `http`, and
+ * the first forwarded host and protocol (what the outermost proxy saw).
+ *
+ * Both schemes for Host, because behind a TLS-terminating proxy the request
+ * URL says `http` while the browser's Origin says `https`. This does not
+ * widen what a cross-origin page can do: the browser sets `Host` itself to
+ * the host it sends the request to, a page cannot choose it (it is a
+ * forbidden header), and `x-forwarded-*` would need a CORS preflight, which
+ * the JSON content type needs anyway. A request whose Origin matches the
+ * Host was therefore sent by a page of that very host; a client that sets
+ * these headers itself is not a browser and carries no victim's cookie. The
+ * one thing added is the plain-http page of the same host, which only a
+ * network attacker could serve, and only where the host is reachable over
+ * http without HSTS. The check consults these origins only for a browser
+ * that sends no `Sec-Fetch-Site`.
+ */
+function publicOrigins(req) {
+    const own = requestUrlOrigin(req);
+    const origins = [own];
+    const host = req.headers.get('host');
+    if (host)
+        origins.push(`https://${host}`, `http://${host}`);
+    const forwardedHost = req.headers.get('x-forwarded-host')?.split(',')[0]?.trim();
+    if (forwardedHost) {
+        const forwardedProto = req.headers.get('x-forwarded-proto')?.split(',')[0]?.trim() || 'https';
+        origins.push(`${forwardedProto}://${forwardedHost}`);
+    }
+    return origins;
+}
 /**
  * Build a RuntimeContext from a Next.js request.
  */
-function buildRuntimeContext(req) {
+function buildRuntimeContext(req, options = {}) {
     return {
-        origin: extractOrigin(req),
+        origin: extractOrigin(req, options),
         cookieHeader: req.headers.get('cookie') ?? undefined,
     };
 }
@@ -44,17 +97,19 @@ function buildToolContext(req, options) {
     return {
         currentDate: new Date(),
         locale: options?.locale ?? 'en-US',
-        runtime: buildRuntimeContext(req),
+        runtime: buildRuntimeContext(req, { trustForwardedHeaders: options?.trustForwardedHeaders }),
     };
 }
 /**
- * Create an InternalApiCaller from a Next.js request.
- * Automatically extracts origin and cookies.
+ * Create an InternalApiCaller from a Next.js request: calls go to
+ * `overrides.origin` when given, else to `extractOrigin(req, overrides)`, and
+ * carry the request's cookie.
  */
 function createInternalApiCallerFromRequest(req, overrides) {
+    const { trustForwardedHeaders, ...callerOverrides } = overrides ?? {};
     return (0, index_js_1.createNextInternalApiCaller)({
-        origin: extractOrigin(req),
+        origin: extractOrigin(req, { trustForwardedHeaders }),
         cookieHeader: req.headers.get('cookie') ?? undefined,
-        ...overrides,
+        ...callerOverrides,
     });
 }

package/dist/cjs/server/adapters/nextjs/create-ai-chat-handler.d.ts

@@ -1,5 +1,7 @@
 import type { PiiShield } from '../../../types.js';
 import type { AiChatHandlerConfig, IntentRoutingResult, PipelineStepReport, PipelineResult, StepLimitSource } from './types.js';
+import { type BudgetEvaluation, type ManagedTurnGuard, type RuntimePriceTable, type TurnMetricsRecorder } from '../../../runtime/index.js';
+import { type HybridToolDiscovery } from './tool-discovery.js';
 /**
  * Callback that the consumer provides to stream the AI response.
  * Receives the prepared context and returns a Response.
@@ -8,7 +10,17 @@ import type { AiChatHandlerConfig, IntentRoutingResult, PipelineStepReport, Pipe
  * calls streamText() themselves with full type safety.
  */
 export interface StreamHandlerContext {
-    /** AI tools (output of toolsToAiTools, RBAC-filtered) */
+    /**
+     * AI tools (output of toolsToAiTools, RBAC-filtered). Every tool that can
+     * ask for approval carries the execution gate of this request: it executes
+     * only for an approval the handler verified (exact tool call id, tool name
+     * and input, once) or for a live call whose `needsApproval` answered false,
+     * and refuses with `approval_not_verified` otherwise, also when the stream
+     * handler builds its own AI SDK tools from these objects. The gate needs the
+     * options the AI SDK passes (`toolCallId`): a stream handler that calls
+     * `tools[name].execute(input)` itself, without them, is refused for every
+     * tool that can ask for approval.
+     */
     tools: Record<string, unknown>;
     /** Processed messages (after guardrails, sliced to context window) */
     messages: unknown[];
@@ -41,6 +53,36 @@ export interface StreamHandlerContext {
         shield: PiiShield;
         sessionId: string;
     };
+    /** Pinned managed-local turn guard, present when managedRuntime is enabled. */
+    managedTurn?: ManagedTurnGuard;
+    /** Immutable turn-local controller for custom stream integrations. */
+    toolDiscovery?: HybridToolDiscovery;
+    /**
+     * Identity set of SDK built-ins (`NON_DOMAIN_TOOL_NAMES`) whose tool
+     * instance this handler created itself for the turn. Only these run outside
+     * the managed guard; a registry- or manifest-supplied tool that merely
+     * shares a built-in's name stays fully guarded (revocation, principal
+     * re-authorization, budget).
+     */
+    handlerBuiltinToolNames?: ReadonlyArray<string>;
+    /**
+     * Content-free metrics of this turn when the handler has `metrics`. The
+     * built-in stream handler reports every step and the outcome; a custom
+     * stream handler reports through it (`recordStep`, `finish`) itself.
+     */
+    turnMetrics?: TurnMetricsRecorder;
+    /** Price table configured on the handler (`modelPricing`). */
+    modelPricing?: RuntimePriceTable;
+    /**
+     * Binds the approval requests of a UI message stream to the tool calls
+     * they announce. The built-in stream handler pipes its UI stream through
+     * this. A custom stream handler that lets tools ask for approval must do
+     * the same with the stream it returns; an approval it issues otherwise is
+     * refused on the next request (`approval_not_issued`).
+     */
+    bindApprovalRequests?: <T extends {
+        type: string;
+    }>(stream: ReadableStream<T>) => ReadableStream<T>;
 }
 /**
  * Extended config that adds an optional streamHandler for full AI SDK control.
@@ -56,6 +98,11 @@ export interface AiChatHandlerFullConfig extends AiChatHandlerConfig {
      * This is where the consumer calls streamText() / toDataStreamResponse().
      *
      * When omitted, the built-in default handler is used.
+     *
+     * The handler ignores a client-set `providerExecuted` flag only on tools of
+     * its own registry: for an approval-gated tool that a custom stream handler
+     * adds itself, a client can set the flag on the approved part, and the
+     * approval is then consumed without the call running.
      */
     streamHandler?: (ctx: StreamHandlerContext) => Promise<Response>;
 }
@@ -71,10 +118,21 @@ export declare function resolveStepLimit(options: {
     moduleMaxSteps?: number | null;
     configuredMaxSteps?: number | null;
     safetyMaxSteps?: number;
+    runtimeBudgetMaxSteps?: number | null;
 }): {
     maxSteps: number;
     stepLimitSource: StepLimitSource;
 };
+export declare function resolveTurnTimeout(totalTimeoutMs: number | undefined): {
+    totalMs: number;
+} | undefined;
+export declare function shouldStopManagedExecution(options: {
+    stepCount: number;
+    maxSteps: number;
+    budgetState?: BudgetEvaluation['state'];
+    /** Tool names called in the latest step; a clarification ends the turn. */
+    lastStepToolNames?: ReadonlyArray<string>;
+}): boolean;
 /**
  * Creates a complete Next.js App Router POST handler for AI chat.
  *