@gedatou/cadenza-ai 0.7.1

package/dist/server/index.d.mts

@@ -0,0 +1,173 @@
+import { o as ThinkingLevel, r as Model } from "../types-56Hn7Qq2.mjs";
+import { n as definePreset, t as ProviderPreset } from "../preset-DRT0T14q.mjs";
+import { ByokProvider, defineByokProvider } from "@tanstack/ai/byok";
+import { byokMissing, getByokKey } from "@tanstack/ai/byok/server";
+import { AgentLoopStrategy, AnySummarizeAdapter, AnyTool, AnyTranscriptionAdapter, ChatMiddleware, DebugOption, StreamDurability, SystemPrompt, chat, chatParamsFromRequest, maxIterations, memoryStream, mergeAgentTools, toServerSentEventsResponse, toolDefinition } from "@tanstack/ai";
+//#region src/server/catalog-handler.d.ts
+/**
+ * `GET /api/ai/catalog`: the pure-data side of each preset plus a coverage map
+ * the browser feeds into `byok.setServerCoverage()`.
+ * `GET ?refresh=1&provider=<id>`: `preset.discoverModels(key)` with the same
+ * header-then-env key the chat handler would use → `{ provider, models }`.
+ */
+interface CatalogHandlerOptions {
+  /**
+   * Hosts an `x-byok-ollama` header may point at; default: loopback and RFC 1918
+   * ranges. Same option and same meaning as on `createChatHandler` — set both,
+   * because `?refresh=1&provider=ollama` fetches that host too.
+   */
+  ollamaHosts?: readonly string[];
+}
+declare function createCatalogHandler(presets: readonly ProviderPreset[], options?: CatalogHandlerOptions): {
+  GET: (request: Request) => Promise<Response>;
+};
+//#endregion
+//#region src/server/selection.d.ts
+interface Selection {
+  preset: ProviderPreset;
+  model: Model;
+  thinking: ThinkingLevel;
+  /** 客户端要的联网搜索，且模型确实声明了这个能力。 */
+  search: boolean;
+}
+/**
+ * Read `provider` / `model` / `thinking` off `forwardedProps` — nothing else on
+ * that object is trusted — and resolve them against the server-side presets.
+ */
+declare function pickSelection(fp: Record<string, unknown>, presets: readonly ProviderPreset[], options: {
+  defaultModel?: string;
+}): Selection | Response;
+//#endregion
+//#region src/server/chat-handler.d.ts
+interface ChatHandlerOptions<TContext = unknown> {
+  providers: readonly ProviderPreset[];
+  /** `provider/model` used when the request carries no selection. */
+  defaultModel?: string;
+  systemPrompts?: SystemPrompt[] | ((selection: Selection) => SystemPrompt[]);
+  /**
+   * Client tools always merge in on top. Prefer the function form whenever any
+   * entry is a provider tool (`webSearchTool()` and friends): those are branded
+   * per vendor, and an adapter that does not recognise the brand silently
+   * degrades the tool into a schema-less function call nothing can execute.
+   */
+  tools?: ReadonlyArray<AnyTool> | ((selection: Selection) => ReadonlyArray<AnyTool>);
+  middleware?: Array<ChatMiddleware<TContext>>;
+  context?: (request: Request) => TContext | Promise<TContext>;
+  agentLoopStrategy?: AgentLoopStrategy;
+  /** Inspect or replace the resolved selection; return a `Response` to refuse the request. */
+  onSelect?: (selection: Selection, request: Request) => Selection | Response;
+  /**
+   * An `AIPersistence<ChatTranscriptStores>` from the optional peer
+   * `@tanstack/ai-persistence`. Typed as `unknown` so this entry's declarations
+   * never reference that package; the peer is imported lazily at request time.
+   */
+  persistence?: unknown;
+  /** `ReconstructChatOptions['authorize']` from `@tanstack/ai-persistence`; only read together with `persistence`. */
+  authorize?: unknown;
+  durability?: (request: Request) => StreamDurability;
+  /** Default 4 MiB. */
+  maxBodyBytes?: number;
+  /** Hosts an `x-byok-ollama` header may point at; default: loopback and RFC 1918 ranges. */
+  ollamaHosts?: readonly string[];
+  debug?: DebugOption;
+}
+interface ChatHandler {
+  POST: (request: Request) => Promise<Response>;
+  GET: (request: Request) => Promise<Response>;
+}
+/**
+ * Route-handler pair for `/api/ai/chat`. The request lifecycle (spec §服务端):
+ * size guard → parse → pick selection → onSelect → BYOK key → adapter →
+ * thinking → chat() → SSE. `GET` serves persistence reconstruction and
+ * durable-stream resumption when those options are present.
+ */
+declare function createChatHandler<TContext = unknown>(options: ChatHandlerOptions<TContext>): ChatHandler;
+//#endregion
+//#region src/server/generation-handlers.d.ts
+interface GenerationHandlerOptions<TAdapter> {
+  /** Builds the adapter with the BYOK / env key; `null` when the provider needs no key. */
+  adapter: (model: string, key: string | null) => TAdapter;
+  /** Which BYOK header / env holds the key; omit for keyless providers. */
+  byok?: ByokProvider;
+  /** Model used unless `forwardedProps.model` names one. */
+  defaultModel: string;
+  /** Default 8 MiB (base64 audio). */
+  maxBodyBytes?: number;
+  debug?: DebugOption;
+}
+interface GenerationHandler {
+  POST: (request: Request) => Promise<Response>;
+}
+/** `POST /api/ai/transcription` for `useTranscription({ connection })`: the body is the generation envelope, the reply an SSE run ending in `generation:result`. */
+declare function createTranscriptionHandler(options: GenerationHandlerOptions<AnyTranscriptionAdapter>): GenerationHandler;
+/** `POST /api/ai/summarize` for `useSummarize({ connection })`; same lifecycle as the transcription handler. */
+declare function createSummarizeHandler(options: GenerationHandlerOptions<AnySummarizeAdapter>): GenerationHandler;
+//#endregion
+//#region src/server/ollama-host.d.ts
+/**
+ * `x-byok-ollama` carries a host URL, not a key: every handler that hands it to
+ * `fetch` has to check it first, or it is a server-side request forgery hole.
+ *
+ * It lives in its own file so the check cannot drift between callers again —
+ * the chat handler had one while the catalog handler's `discoverModels` path
+ * did not, and the only thing recording that dependency was a comment in
+ * `providers/ollama.ts` saying the chat handler had already checked.
+ */
+/**
+ * Whether `host` — the raw `x-byok-ollama` value — may be fetched.
+ *
+ * `allow` is the deployer's own list (`ollamaHosts`), matched exactly against
+ * `host` or `hostname`. Without one, only loopback and the private ranges pass.
+ */
+declare function ollamaHostAllowed(host: string, allow?: readonly string[]): boolean;
+//#endregion
+//#region src/server/thinking.d.ts
+type Fragment = Record<string, unknown>;
+type Effort3 = 'low' | 'medium' | 'high';
+/** 三档 effort 的 provider（grok / groq / vercel-gateway / ollama gpt-oss）共用的折叠表。 */
+declare const EFFORT_3: Record<Exclude<ThinkingLevel, 'off'>, Effort3>;
+/** clamp 到模型支持的档位后再交给 preset；非推理模型关着时不发任何片段。 */
+declare function resolveThinking(preset: ProviderPreset, model: Model, level: ThinkingLevel): Fragment;
+declare function openaiThinking(level: ThinkingLevel, model: Model): Fragment;
+declare function anthropicThinking(level: ThinkingLevel, model: Model): Fragment;
+declare function geminiThinking(level: ThinkingLevel, model: Model): Fragment;
+declare function openrouterThinking(level: ThinkingLevel, _model: Model): Fragment;
+declare function grokThinking(level: ThinkingLevel, model: Model): Fragment;
+declare function groqThinking(level: ThinkingLevel, model: Model): Fragment;
+declare function vercelGatewayThinking(level: ThinkingLevel, _model: Model): Fragment;
+declare function llmgatewayThinking(level: ThinkingLevel, _model: Model): Fragment;
+declare function ollamaThinking(level: ThinkingLevel, model: Model): Fragment;
+declare function openaiCompatibleThinking(level: ThinkingLevel, model: Model): Fragment;
+declare function deepseekThinking(level: ThinkingLevel, model: Model): Fragment;
+declare function deepseekResponsesThinking(level: ThinkingLevel, model: Model): Fragment;
+declare function noThinking(_level: ThinkingLevel, _model: Model): Fragment;
+//#endregion
+//#region src/server/title-handler.d.ts
+interface TitleHandlerOptions {
+  providers: readonly ProviderPreset[];
+  /** `vendor/model` used when `forwardedProps` names none; normally the conversation's own selection arrives. */
+  defaultModel?: string;
+  /** Upper bound the instruction asks for. Default 6 — a sidebar row, not a sentence. */
+  maxWords?: number;
+  /** Replace the instruction; receives `maxWords`. */
+  prompt?: (maxWords: number) => string;
+  /** Default 1 MiB. */
+  maxBodyBytes?: number;
+  debug?: DebugOption;
+}
+/**
+ * The ChatGPT rule: name the conversation from its first exchange, in the
+ * user's language, a handful of words, nothing around it.
+ */
+declare function defaultTitlePrompt(maxWords: number): string;
+/** Strip what models add anyway — fences, a `Title:` label, quotes, trailing punctuation — and keep one line. */
+declare function cleanTitle(raw: string, maxLength?: number): string;
+/**
+ * `POST /api/ai/title` for `useSummarize({ connection })`: the same envelope and
+ * SSE reply as the summarize handler, but the model is whichever the
+ * conversation selected (`forwardedProps.provider` / `model`, thinking off), and
+ * the reply is a title, not a summary.
+ */
+declare function createTitleHandler(options: TitleHandlerOptions): GenerationHandler;
+//#endregion
+export { CatalogHandlerOptions, ChatHandler, ChatHandlerOptions, EFFORT_3, GenerationHandler, GenerationHandlerOptions, ProviderPreset, Selection, TitleHandlerOptions, anthropicThinking, byokMissing, chat, chatParamsFromRequest, cleanTitle, createCatalogHandler, createChatHandler, createSummarizeHandler, createTitleHandler, createTranscriptionHandler, deepseekResponsesThinking, deepseekThinking, defaultTitlePrompt, defineByokProvider, definePreset, geminiThinking, getByokKey, grokThinking, groqThinking, llmgatewayThinking, maxIterations, memoryStream, mergeAgentTools, noThinking, ollamaHostAllowed, ollamaThinking, openaiCompatibleThinking, openaiThinking, openrouterThinking, pickSelection, resolveThinking, toServerSentEventsResponse, toolDefinition, vercelGatewayThinking };

package/dist/server/index.mjs

@@ -0,0 +1,440 @@
+import { r as parseModelRef } from "../catalog-CvvS2JaW.mjs";
+import { n as clampThinkingLevel, t as THINKING_LEVELS } from "../thinking-CH2uL1dr.mjs";
+import { a as deepseekThinking, c as groqThinking, d as ollamaThinking, f as openaiCompatibleThinking, g as vercelGatewayThinking, h as resolveThinking, i as deepseekResponsesThinking, l as llmgatewayThinking, m as openrouterThinking, n as EFFORT_3, o as geminiThinking, p as openaiThinking, r as anthropicThinking, s as grokThinking, t as definePreset, u as noThinking } from "../preset-CEyIPxfS.mjs";
+import { defineByokProvider } from "@tanstack/ai/byok";
+import { byokMissing, byokMissing as byokMissing$1, getByokKey, getByokKey as getByokKey$1 } from "@tanstack/ai/byok/server";
+import { chat, chat as chat$1, chatParamsFromRequest, chatParamsFromRequest as chatParamsFromRequest$1, generateTranscription, generationParamsFromRequest, maxIterations, memoryStream, mergeAgentTools, mergeAgentTools as mergeAgentTools$1, summarize, toServerSentEventsResponse, toServerSentEventsResponse as toServerSentEventsResponse$1, toolDefinition } from "@tanstack/ai";
+//#region src/server/ollama-host.ts
+/**
+* `x-byok-ollama` carries a host URL, not a key: every handler that hands it to
+* `fetch` has to check it first, or it is a server-side request forgery hole.
+*
+* It lives in its own file so the check cannot drift between callers again —
+* the chat handler had one while the catalog handler's `discoverModels` path
+* did not, and the only thing recording that dependency was a comment in
+* `providers/ollama.ts` saying the chat handler had already checked.
+*/
+/**
+* Loopback and RFC 1918, decided by parsing the address.
+*
+* Prefix-matching the hostname does not work: `10.attacker.com` starts with
+* `10.` and is an ordinary domain that resolves wherever its owner points it,
+* so a string test hands the allowlist to the attacker.
+*/
+function isPrivateHost(hostname) {
+	if (hostname === "localhost" || hostname === "[::1]") return true;
+	const parts = hostname.split(".");
+	if (parts.length !== 4 || parts.some((p) => !/^\d{1,3}$/.test(p))) return false;
+	const [a = -1, b = -1] = parts.map(Number);
+	if (a > 255 || b > 255) return false;
+	return a === 127 || a === 10 || a === 192 && b === 168 || a === 172 && b >= 16 && b <= 31;
+}
+/**
+* Whether `host` — the raw `x-byok-ollama` value — may be fetched.
+*
+* `allow` is the deployer's own list (`ollamaHosts`), matched exactly against
+* `host` or `hostname`. Without one, only loopback and the private ranges pass.
+*/
+function ollamaHostAllowed(host, allow) {
+	let url;
+	try {
+		url = new URL(host);
+	} catch {
+		return false;
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") return false;
+	return allow ? allow.some((a) => url.host === a || url.hostname === a) : isPrivateHost(url.hostname);
+}
+//#endregion
+//#region src/server/catalog-handler.ts
+function hasEnv(...names) {
+	return names.some((n) => {
+		const v = process.env[n];
+		return v !== void 0 && v !== "";
+	});
+}
+/** Whether the server can run this provider without a browser-supplied key. */
+function covered(p) {
+	if (!p.keyRequired) {
+		if (p.id !== "vertex") return true;
+		return hasEnv("GOOGLE_VERTEX_API_KEY") || hasEnv("GOOGLE_CLOUD_PROJECT", "GOOGLE_VERTEX_PROJECT") && hasEnv("GOOGLE_CLOUD_LOCATION", "GOOGLE_VERTEX_LOCATION");
+	}
+	return hasEnv(...p.byok?.env ?? []);
+}
+function json(status, body) {
+	return new Response(JSON.stringify(body), {
+		status,
+		headers: { "content-type": "application/json" }
+	});
+}
+function createCatalogHandler(presets, options = {}) {
+	return { GET: async (request) => {
+		const url = new URL(request.url);
+		if (url.searchParams.get("refresh") === "1") {
+			const id = url.searchParams.get("provider");
+			const preset = presets.find((p) => p.id === id);
+			if (!preset) return json(400, { error: { type: "unknown_provider" } });
+			if (!preset.discoverModels) return json(400, { error: {
+				type: "discover_unsupported",
+				provider: preset.id
+			} });
+			const key = preset.byok ? getByokKey$1(request, preset.byok) : null;
+			if (preset.id === "ollama" && key !== null && !ollamaHostAllowed(key, options.ollamaHosts)) return json(400, { error: {
+				type: "host_not_allowed",
+				provider: preset.id
+			} });
+			try {
+				return Response.json({
+					provider: preset.id,
+					models: await preset.discoverModels(key)
+				});
+			} catch {
+				return json(502, { error: {
+					type: "discover_failed",
+					provider: preset.id
+				} });
+			}
+		}
+		const providers = presets.map(({ create: _c, thinking: _t, discoverModels: _d, ...rest }) => rest);
+		const coverage = Object.fromEntries(presets.map((p) => [p.id, covered(p)]));
+		return Response.json({
+			providers,
+			coverage,
+			generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+	} };
+}
+//#endregion
+//#region src/server/selection.ts
+const MODEL_ID$1 = /^[\w.\-:/~]{1,200}$/;
+function bad$1(type) {
+	return new Response(JSON.stringify({ error: { type } }), {
+		status: 400,
+		headers: { "content-type": "application/json" }
+	});
+}
+/**
+* Read `provider` / `model` / `thinking` off `forwardedProps` — nothing else on
+* that object is trusted — and resolve them against the server-side presets.
+*/
+function pickSelection(fp, presets, options) {
+	let provider = typeof fp.provider === "string" ? fp.provider : void 0;
+	let modelId = typeof fp.model === "string" ? fp.model : void 0;
+	if ((provider === void 0 || modelId === void 0) && options.defaultModel !== void 0) {
+		const d = parseModelRef(options.defaultModel);
+		provider ??= d.provider;
+		modelId ??= d.id;
+	}
+	if (provider === void 0 || modelId === void 0 || modelId === "") return bad$1("unknown_model");
+	const preset = presets.find((p) => p.id === provider);
+	if (!preset) return bad$1("unknown_provider");
+	if (!MODEL_ID$1.test(modelId)) return bad$1("unknown_model");
+	let model = preset.models.find((m) => m.id === modelId);
+	if (!model) {
+		if (!preset.discoverModels) return bad$1("unknown_model");
+		model = {
+			id: modelId,
+			name: modelId,
+			provider: preset.id,
+			input: ["text"],
+			reasoning: false
+		};
+	}
+	const raw = typeof fp.thinking === "string" && THINKING_LEVELS.includes(fp.thinking) ? fp.thinking : "off";
+	return {
+		preset,
+		model,
+		thinking: clampThinkingLevel(model, raw),
+		search: fp.search === true && model.search === true
+	};
+}
+//#endregion
+//#region src/server/chat-handler.ts
+/**
+* Route-handler pair for `/api/ai/chat`. The request lifecycle (spec §服务端):
+* size guard → parse → pick selection → onSelect → BYOK key → adapter →
+* thinking → chat() → SSE. `GET` serves persistence reconstruction and
+* durable-stream resumption when those options are present.
+*/
+function createChatHandler(options) {
+	const onVercel = process.env.VERCEL === "1";
+	const presets = options.providers.filter((p) => !(onVercel && p.runtime === "local"));
+	const maxBody = options.maxBodyBytes ?? 4194304;
+	async function POST(request) {
+		const declared = request.headers.get("content-length");
+		if (declared !== null && !(Number(declared) <= maxBody)) return new Response("Payload too large", { status: 413 });
+		let params;
+		try {
+			params = await chatParamsFromRequest$1(request);
+		} catch (error) {
+			if (error instanceof Response) return error;
+			throw error;
+		}
+		const picked = pickSelection(params.forwardedProps ?? {}, presets, { defaultModel: options.defaultModel });
+		if (picked instanceof Response) return picked;
+		const selection = options.onSelect ? options.onSelect(picked, request) : picked;
+		if (selection instanceof Response) return selection;
+		const { preset, model, thinking } = selection;
+		const key = preset.byok ? getByokKey$1(request, preset.byok) : null;
+		if (preset.keyRequired && key === null && preset.byok) return byokMissing$1(preset.byok);
+		if (preset.id === "ollama" && key !== null && !ollamaHostAllowed(key, options.ollamaHosts)) return new Response("Ollama host not allowed", { status: 400 });
+		const adapter = preset.create(model.id, key);
+		const modelOptions = resolveThinking(preset, model, thinking);
+		const abortController = new AbortController();
+		const middleware = [...options.middleware ?? []];
+		if (options.persistence !== void 0) {
+			const { withPersistence } = await import("@tanstack/ai-persistence");
+			middleware.push(withPersistence(options.persistence));
+		}
+		const context = options.context ? await options.context(request) : void 0;
+		const stream = chat$1({
+			adapter,
+			messages: params.messages,
+			threadId: params.threadId,
+			runId: params.runId,
+			parentRunId: params.parentRunId,
+			resume: params.resume,
+			tools: mergeAgentTools$1(typeof options.tools === "function" ? options.tools(selection) : options.tools ?? [], params.tools),
+			systemPrompts: typeof options.systemPrompts === "function" ? options.systemPrompts(selection) : options.systemPrompts,
+			modelOptions,
+			middleware,
+			agentLoopStrategy: options.agentLoopStrategy,
+			context,
+			abortController,
+			debug: options.debug
+		});
+		return toServerSentEventsResponse$1(stream, {
+			abortController,
+			...options.durability ? { durability: { adapter: options.durability(request) } } : {},
+			debug: options.debug
+		});
+	}
+	async function GET(request) {
+		const url = new URL(request.url);
+		if (options.persistence !== void 0 && url.searchParams.has("threadId")) {
+			const { reconstructChat } = await import("@tanstack/ai-persistence");
+			return reconstructChat(options.persistence, request, { authorize: options.authorize });
+		}
+		if (options.durability && (url.searchParams.has("runId") || request.headers.has("last-event-id"))) {
+			const { resumeServerSentEventsResponse } = await import("@tanstack/ai");
+			return resumeServerSentEventsResponse({ adapter: options.durability(request) });
+		}
+		return new Response("Not found", { status: 404 });
+	}
+	return {
+		POST,
+		GET
+	};
+}
+//#endregion
+//#region src/server/envelope.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+const SUMMARY_STYLES = [
+	"bullet-points",
+	"paragraph",
+	"concise"
+];
+async function summarizeParamsFromRequest(request) {
+	let body;
+	try {
+		body = await request.json();
+	} catch {
+		throw new Error("Invalid JSON request body.");
+	}
+	if (!isRecord(body)) throw new Error("Summarize request body must be a JSON object.");
+	const input = isRecord(body.data) ? body.data : body;
+	if (typeof input.text !== "string") throw new Error("Summarize input must include text.");
+	const style = SUMMARY_STYLES.find((s) => s === input.style);
+	const focus = Array.isArray(input.focus) ? input.focus.filter((f) => typeof f === "string") : void 0;
+	return {
+		input: {
+			text: input.text,
+			maxLength: typeof input.maxLength === "number" ? input.maxLength : void 0,
+			style,
+			focus
+		},
+		forwardedProps: isRecord(body.forwardedProps) ? body.forwardedProps : {},
+		threadId: typeof body.threadId === "string" ? body.threadId : void 0,
+		runId: typeof body.runId === "string" ? body.runId : void 0
+	};
+}
+//#endregion
+//#region src/server/generation-handlers.ts
+const MODEL_ID = /^[\w.\-:/~]{1,200}$/;
+function bad(message, type) {
+	return type === void 0 ? new Response(message, { status: 400 }) : new Response(JSON.stringify({ error: { type } }), {
+		status: 400,
+		headers: { "content-type": "application/json" }
+	});
+}
+/**
+* The part of the lifecycle both handlers share (spec §服务端, mirrored from
+* `createChatHandler`): size guard → parse → model → BYOK key → adapter.
+*/
+async function resolve(request, options, parse) {
+	if (Number(request.headers.get("content-length") ?? 0) > (options.maxBodyBytes ?? 8388608)) return new Response("Payload too large", { status: 413 });
+	let params;
+	try {
+		params = await parse(request);
+	} catch (error) {
+		if (error instanceof Response) return error;
+		return bad(error instanceof Error ? error.message : "Invalid request body");
+	}
+	const requested = params.forwardedProps.model;
+	let model = options.defaultModel;
+	if (requested !== void 0) {
+		if (typeof requested !== "string" || !MODEL_ID.test(requested)) return bad("unknown model", "unknown_model");
+		model = requested;
+	}
+	const key = options.byok ? getByokKey$1(request, options.byok) : null;
+	if (options.byok && key === null) return byokMissing$1(options.byok);
+	return {
+		params,
+		adapter: options.adapter(model, key)
+	};
+}
+/** `POST /api/ai/transcription` for `useTranscription({ connection })`: the body is the generation envelope, the reply an SSE run ending in `generation:result`. */
+function createTranscriptionHandler(options) {
+	return { POST: async (request) => {
+		const resolved = await resolve(request, options, (req) => generationParamsFromRequest("transcription", req));
+		if (resolved instanceof Response) return resolved;
+		const { input, threadId, runId } = resolved.params;
+		if (typeof input.audio !== "string") return bad("Transcription audio must be a base64 or data-URL string.");
+		const abortController = new AbortController();
+		const stream = generateTranscription({
+			adapter: resolved.adapter,
+			audio: input.audio,
+			language: input.language,
+			prompt: input.prompt,
+			responseFormat: input.responseFormat,
+			threadId,
+			runId,
+			stream: true,
+			abortSignal: abortController.signal,
+			debug: options.debug
+		});
+		return toServerSentEventsResponse$1(stream, {
+			abortController,
+			debug: options.debug
+		});
+	} };
+}
+/** `POST /api/ai/summarize` for `useSummarize({ connection })`; same lifecycle as the transcription handler. */
+function createSummarizeHandler(options) {
+	return { POST: async (request) => {
+		const resolved = await resolve(request, options, summarizeParamsFromRequest);
+		if (resolved instanceof Response) return resolved;
+		const { input, threadId, runId } = resolved.params;
+		const abortController = new AbortController();
+		const stream = summarize({
+			adapter: resolved.adapter,
+			...input,
+			threadId,
+			runId,
+			stream: true,
+			abortSignal: abortController.signal,
+			debug: options.debug
+		});
+		return toServerSentEventsResponse$1(stream, {
+			abortController,
+			debug: options.debug
+		});
+	} };
+}
+//#endregion
+//#region src/server/title-handler.ts
+/**
+* The ChatGPT rule: name the conversation from its first exchange, in the
+* user's language, a handful of words, nothing around it.
+*/
+function defaultTitlePrompt(maxWords) {
+	return [
+		"You name conversations.",
+		`Given the first exchange of a chat, reply with a title of at most ${maxWords} words, in the language the user wrote in.`,
+		"Output only the title: no quotes, no trailing punctuation, no markdown, no explanation."
+	].join(" ");
+}
+const WRAPPING = /^["'“”‘’«»「」『』`*_\s]+|["'“”‘’«»「」『』`*_\s]+$/g;
+const TRAILING = /[.。!！?？:：;；,，、]+$/;
+/** Strip what models add anyway — fences, a `Title:` label, quotes, trailing punctuation — and keep one line. */
+function cleanTitle(raw, maxLength = 80) {
+	const title = (raw.replace(/```[a-z]*/gi, " ").split("\n").map((l) => l.trim()).find((l) => l !== "") ?? "").replace(/^title\s*[:：]\s*/i, "").replace(WRAPPING, "").replace(TRAILING, "").replace(/\s+/g, " ").trim();
+	return title.length > maxLength ? `${title.slice(0, maxLength)}…` : title;
+}
+/** A summarize adapter over a text adapter: the summary is the title, so `useSummarize` on the client needs no new protocol. */
+function titleAdapter(adapter, systemPrompt, modelOptions) {
+	const model = adapter.model;
+	return {
+		"kind": "summarize",
+		"name": adapter.name,
+		"model": model,
+		"~types": { providerOptions: {} },
+		"summarize": async ({ text, abortSignal }) => {
+			const abortController = new AbortController();
+			abortSignal?.addEventListener("abort", () => abortController.abort(), { once: true });
+			const raw = await chat$1({
+				adapter,
+				messages: [{
+					role: "user",
+					content: text
+				}],
+				systemPrompts: [systemPrompt],
+				modelOptions,
+				stream: false,
+				abortController
+			});
+			return {
+				id: crypto.randomUUID(),
+				model,
+				summary: cleanTitle(raw),
+				usage: {
+					promptTokens: 0,
+					completionTokens: 0,
+					totalTokens: 0
+				}
+			};
+		}
+	};
+}
+/**
+* `POST /api/ai/title` for `useSummarize({ connection })`: the same envelope and
+* SSE reply as the summarize handler, but the model is whichever the
+* conversation selected (`forwardedProps.provider` / `model`, thinking off), and
+* the reply is a title, not a summary.
+*/
+function createTitleHandler(options) {
+	const systemPrompt = (options.prompt ?? defaultTitlePrompt)(options.maxWords ?? 6);
+	return { POST: async (request) => {
+		if (Number(request.headers.get("content-length") ?? 0) > (options.maxBodyBytes ?? 1048576)) return new Response("Payload too large", { status: 413 });
+		let params;
+		try {
+			params = await summarizeParamsFromRequest(request);
+		} catch (error) {
+			return new Response(error instanceof Error ? error.message : "Invalid request body", { status: 400 });
+		}
+		const picked = pickSelection(params.forwardedProps, options.providers, { defaultModel: options.defaultModel });
+		if (picked instanceof Response) return picked;
+		const { preset, model } = picked;
+		const key = preset.byok ? getByokKey$1(request, preset.byok) : null;
+		if (preset.keyRequired && key === null && preset.byok) return byokMissing$1(preset.byok);
+		const adapter = titleAdapter(preset.create(model.id, key), systemPrompt, resolveThinking(preset, model, "off"));
+		const abortController = new AbortController();
+		const stream = summarize({
+			adapter,
+			text: params.input.text,
+			threadId: params.threadId,
+			runId: params.runId,
+			stream: true,
+			abortSignal: abortController.signal,
+			debug: options.debug
+		});
+		return toServerSentEventsResponse$1(stream, {
+			abortController,
+			debug: options.debug
+		});
+	} };
+}
+//#endregion
+export { EFFORT_3, anthropicThinking, byokMissing, chat, chatParamsFromRequest, cleanTitle, createCatalogHandler, createChatHandler, createSummarizeHandler, createTitleHandler, createTranscriptionHandler, deepseekResponsesThinking, deepseekThinking, defaultTitlePrompt, defineByokProvider, definePreset, geminiThinking, getByokKey, grokThinking, groqThinking, llmgatewayThinking, maxIterations, memoryStream, mergeAgentTools, noThinking, ollamaHostAllowed, ollamaThinking, openaiCompatibleThinking, openaiThinking, openrouterThinking, pickSelection, resolveThinking, toServerSentEventsResponse, toolDefinition, vercelGatewayThinking };

package/dist/thinking-CH2uL1dr.mjs

@@ -0,0 +1,26 @@
+//#region src/catalog/thinking.ts
+const THINKING_LEVELS = [
+	"off",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+function supportedThinkingLevels(model) {
+	if (!model || !model.reasoning) return ["off"];
+	return model.thinkingLevels ?? THINKING_LEVELS;
+}
+/**
+* 向下取最近支持档；目标低于模型下限（Fable 5 这类不可关的模型）时取下限。
+*/
+function clampThinkingLevel(model, level) {
+	const supported = supportedThinkingLevels(model);
+	if (supported.includes(level)) return level;
+	const rank = (l) => THINKING_LEVELS.indexOf(l);
+	const below = supported.filter((l) => rank(l) < rank(level));
+	return below.length > 0 ? below[below.length - 1] : supported[0];
+}
+//#endregion
+export { clampThinkingLevel as n, supportedThinkingLevels as r, THINKING_LEVELS as t };