@gedatou/cadenza-ai 0.7.1

package/dist/mock/index.mjs

@@ -0,0 +1,467 @@
+"use client";
+import { EventType, INTERRUPT_BINDING_METADATA_KEY, INTERRUPT_BINDING_VERSION, canonicalInterruptJson, digestInterruptJson, generateMessageId, hashSchemaInput, normalizeApprovalSchema } from "@tanstack/ai/client";
+//#region src/mock/steps.ts
+/** Assistant text. Several `text` steps in one run share a single assistant message. */
+const text = (content, o = {}) => ({
+	kind: "text",
+	content,
+	...o
+});
+/** A thinking block; `signature` is attached via `STEP_FINISHED` the way the engine does it. */
+const reasoning = (content, o = {}) => ({
+	kind: "reasoning",
+	content,
+	...o
+});
+/**
+* A tool call. Without `approval` / `client` the result follows immediately;
+* with either, the run finishes on an interrupt and `tool.result` continues it next turn.
+*/
+const tool = Object.assign((name, input, o = {}) => ({
+	kind: "tool",
+	name,
+	input,
+	...o
+}), { result: (toolCallId, output, o = {}) => ({
+	kind: "tool-result",
+	toolCallId,
+	output,
+	...o
+}) });
+const custom = (name, value) => ({
+	kind: "custom",
+	name,
+	value
+});
+const structured = (object, o = {}) => ({
+	kind: "structured",
+	object,
+	...o
+});
+/** Token usage for the run. `details` carries the fields with no spec slot, through the same leftover channel the real transport uses. */
+const usage = (u, details) => ({
+	kind: "usage",
+	usage: u,
+	...details ? { details } : {}
+});
+const error = (message, code) => ({
+	kind: "error",
+	message,
+	code
+});
+const sleep = (ms) => ({
+	kind: "sleep",
+	ms
+});
+const finish = (o = {}) => ({
+	kind: "finish",
+	...o
+});
+//#endregion
+//#region src/mock/run.ts
+const DEFAULT_PACE = 24;
+const INPUT_SCHEMA = {
+	type: "object",
+	additionalProperties: true
+};
+const CLIENT_RESPONSE_SCHEMA = { type: "object" };
+/** Turn a step script into a `ChatFetcher` for `useChat({ fetcher })`. */
+function scripted(script, options = {}) {
+	let turn = 0;
+	return async (input, { signal }) => {
+		const ctx = toContext(input, signal, turn++);
+		const out = await script(ctx);
+		if (out instanceof Response) return out;
+		const chunks = run(ctx, out, options);
+		return options.sse ? toSseResponse(chunks, signal) : chunks;
+	};
+}
+/** The wire shape `toServerSentEventsResponse` emits: one `data:` line per chunk, blank-line separated. */
+function toSseResponse(chunks, signal) {
+	const encoder = new TextEncoder();
+	const body = new ReadableStream({ async start(controller) {
+		try {
+			for await (const chunk of chunks) {
+				if (signal.aborted) break;
+				controller.enqueue(encoder.encode(`data: ${JSON.stringify(chunk)}\n\n`));
+			}
+		} catch (error) {
+			controller.error(error);
+			return;
+		}
+		controller.close();
+	} });
+	return new Response(body, {
+		status: 200,
+		headers: {
+			"content-type": "text/event-stream",
+			"cache-control": "no-cache"
+		}
+	});
+}
+/** Turn n answers with `turns[n]`; past the end the last entry repeats. */
+function sequence(turns) {
+	return (ctx) => {
+		const t = turns[Math.min(ctx.turn, turns.length - 1)] ?? [];
+		return typeof t === "function" ? t(ctx) : t;
+	};
+}
+/** Pick the first rule whose matcher hits `lastUserText`; otherwise `fallback` (default: `echo()`). */
+function respond(rules, fallback = echo()) {
+	return (ctx) => {
+		const hit = rules.find(([match]) => typeof match === "function" ? match(ctx) : typeof match === "string" ? ctx.lastUserText.includes(match) : match.test(ctx.lastUserText));
+		const reply = hit ? hit[1] : fallback;
+		return typeof reply === "function" ? reply(ctx) : reply;
+	};
+}
+/** Repeat the last user message, listing attachment MIME types and `data.model` when present. */
+function echo(options = {}) {
+	return (ctx) => {
+		const mimes = (ctx.lastUser?.parts ?? []).map((p) => "source" in p ? p.source.mimeType : void 0).filter((m) => typeof m === "string");
+		const lines = [ctx.lastUserText];
+		if (mimes.length > 0) lines.push(`Attachments: ${mimes.join(", ")}`);
+		if (typeof ctx.data.model === "string") lines.push(`Model: ${ctx.data.model}`);
+		return [text(lines.join("\n\n"), options)];
+	};
+}
+/** A 401 the client turns into `byok.request(provider, 'missing')`. Return it from a script. */
+function byokMissing(provider) {
+	return new Response(JSON.stringify({ error: {
+		type: "byok_missing",
+		provider,
+		message: `Missing ${provider} API key`
+	} }), {
+		status: 401,
+		headers: { "content-type": "application/json" }
+	});
+}
+/** The user's decision for `tool(name, input, { approval: true })` from the previous run, if resolved. */
+function approvalOf(ctx, toolCallId) {
+	const payload = resolved(ctx, `approval_${toolCallId}`)?.payload;
+	if (typeof payload === "boolean") return { approved: payload };
+	if (typeof payload === "object" && payload !== null && "approved" in payload && typeof payload.approved === "boolean") {
+		const { approved, editedArgs, payload: extra } = payload;
+		return {
+			approved,
+			...editedArgs !== void 0 && { editedArgs },
+			...extra !== void 0 && { payload: extra }
+		};
+	}
+}
+/** The client-side output for `tool(name, input, { client: true })` from the previous run, if resolved. */
+function clientResultOf(ctx, toolCallId) {
+	return resolved(ctx, `client_tool_${toolCallId}`)?.payload;
+}
+function resolved(ctx, interruptId) {
+	return ctx.resume?.find((r) => r.interruptId === interruptId && r.status === "resolved");
+}
+function toContext(input, signal, turn) {
+	const lastUser = input.messages.findLast((m) => m.role === "user");
+	return {
+		messages: input.messages,
+		lastUser,
+		lastUserText: lastUser?.parts.map((p) => p.type === "text" ? p.content : "").join("") ?? "",
+		data: input.data ?? {},
+		threadId: input.threadId,
+		runId: input.runId,
+		parentRunId: input.parentRunId,
+		resume: input.resume,
+		turn,
+		signal
+	};
+}
+function wait(signal, ms) {
+	if (ms <= 0 || signal.aborted) return Promise.resolve();
+	return new Promise((resolve) => {
+		let timer;
+		const done = () => {
+			clearTimeout(timer);
+			signal.removeEventListener("abort", done);
+			resolve();
+		};
+		timer = setTimeout(done, ms);
+		signal.addEventListener("abort", done, { once: true });
+	});
+}
+function split(content, chunk) {
+	if (chunk === "char") return Array.from(content);
+	if (chunk === "word") return content.match(/\S+\s*|\s+/g) ?? [];
+	const size = Math.max(1, Math.floor(chunk));
+	const out = [];
+	for (let i = 0; i < content.length; i += size) out.push(content.slice(i, i + size));
+	return out;
+}
+async function* run(ctx, steps, options) {
+	const { signal, threadId, runId, parentRunId } = ctx;
+	const pace = options.pace === "instant" ? 0 : options.pace ?? DEFAULT_PACE;
+	const chunking = options.chunk ?? "word";
+	const messageId = options.messageId?.() ?? generateMessageId();
+	const pending = [];
+	let textStarted = false;
+	let runUsage;
+	let runUsageDetails;
+	let finishReason;
+	yield {
+		type: EventType.RUN_STARTED,
+		threadId,
+		runId,
+		...parentRunId !== void 0 && { parentRunId }
+	};
+	async function* deltas(content, chunk, stepPace) {
+		for (const delta of split(content, chunk ?? chunking)) {
+			await wait(signal, stepPace ?? pace);
+			if (signal.aborted) return false;
+			yield delta;
+		}
+		return true;
+	}
+	for await (const step of steps) {
+		if (signal.aborted) return;
+		switch (step.kind) {
+			case "text":
+				if (!textStarted) {
+					textStarted = true;
+					yield {
+						type: EventType.TEXT_MESSAGE_START,
+						messageId,
+						role: "assistant"
+					};
+				}
+				for await (const delta of deltas(step.content, step.chunk, step.pace)) yield {
+					type: EventType.TEXT_MESSAGE_CONTENT,
+					messageId,
+					delta
+				};
+				break;
+			case "reasoning": {
+				const stepId = generateMessageId();
+				yield {
+					type: EventType.STEP_STARTED,
+					stepName: stepId
+				};
+				yield {
+					type: EventType.REASONING_START,
+					messageId: stepId
+				};
+				yield {
+					type: EventType.REASONING_MESSAGE_START,
+					messageId: stepId,
+					role: "reasoning"
+				};
+				for await (const delta of deltas(step.content, step.chunk, step.pace)) yield {
+					type: EventType.REASONING_MESSAGE_CONTENT,
+					messageId: stepId,
+					delta
+				};
+				yield {
+					type: EventType.REASONING_MESSAGE_END,
+					messageId: stepId
+				};
+				yield {
+					type: EventType.REASONING_END,
+					messageId: stepId
+				};
+				if (step.signature !== void 0) yield {
+					type: EventType.STEP_FINISHED,
+					stepName: stepId,
+					signature: step.signature
+				};
+				break;
+			}
+			case "tool": {
+				const toolCallId = step.toolCallId ?? options.toolCallId?.() ?? generateMessageId();
+				const metadata = step.providerExecuted ? {
+					...step.metadata,
+					providerExecuted: true
+				} : step.metadata;
+				yield {
+					type: EventType.TOOL_CALL_START,
+					toolCallId,
+					toolCallName: step.name,
+					parentMessageId: messageId,
+					...metadata && { metadata }
+				};
+				const args = JSON.stringify(step.input ?? {});
+				const argsChunk = step.argsChunk ?? options.argsChunk;
+				for (const delta of argsChunk !== void 0 ? split(args, argsChunk) : [args]) {
+					await wait(signal, pace);
+					if (signal.aborted) return;
+					yield {
+						type: EventType.TOOL_CALL_ARGS,
+						toolCallId,
+						delta
+					};
+				}
+				yield {
+					type: EventType.TOOL_CALL_END,
+					toolCallId,
+					input: step.input
+				};
+				if (step.approval || step.client) {
+					pending.push({
+						name: step.name,
+						toolCallId,
+						input: step.input,
+						client: Boolean(step.client)
+					});
+					break;
+				}
+				yield toolResult(toolCallId, step.error !== void 0 ? { error: step.error } : step.output, step.error !== void 0);
+				break;
+			}
+			case "tool-result":
+				yield toolResult(step.toolCallId, step.output, Boolean(step.error));
+				break;
+			case "custom":
+				yield {
+					type: EventType.CUSTOM,
+					name: step.name,
+					value: step.value
+				};
+				break;
+			case "structured": {
+				const raw = JSON.stringify(step.object);
+				yield {
+					type: EventType.CUSTOM,
+					name: "structured-output.start",
+					value: { messageId }
+				};
+				if (!textStarted) {
+					textStarted = true;
+					yield {
+						type: EventType.TEXT_MESSAGE_START,
+						messageId,
+						role: "assistant"
+					};
+				}
+				for await (const delta of deltas(raw, step.chunk ?? 8, void 0)) yield {
+					type: EventType.TEXT_MESSAGE_CONTENT,
+					messageId,
+					delta
+				};
+				yield {
+					type: EventType.CUSTOM,
+					name: "structured-output.complete",
+					value: {
+						object: step.object,
+						raw
+					}
+				};
+				break;
+			}
+			case "usage":
+				runUsage = step.usage;
+				runUsageDetails = step.details;
+				break;
+			case "error":
+				yield {
+					type: EventType.RUN_ERROR,
+					message: step.message,
+					...step.code !== void 0 && { code: step.code }
+				};
+				return;
+			case "sleep":
+				await wait(signal, step.ms);
+				break;
+			case "finish": finishReason = step.finishReason;
+		}
+		if (signal.aborted) return;
+	}
+	if (textStarted) yield {
+		type: EventType.TEXT_MESSAGE_END,
+		messageId
+	};
+	if (pending.length > 0) {
+		yield {
+			type: EventType.RUN_FINISHED,
+			threadId,
+			runId,
+			outcome: {
+				type: "interrupt",
+				interrupts: pending.map((p) => p.client ? clientToolInterrupt(runId, p) : approvalInterrupt(runId, p))
+			},
+			metadata: { tanstack: { finishReason: "tool_calls" } }
+		};
+		return;
+	}
+	yield {
+		type: EventType.RUN_FINISHED,
+		threadId,
+		runId,
+		...runUsage && { usage: [{
+			...runUsage,
+			totalTokens: runUsage.inputTokens + runUsage.outputTokens
+		}] },
+		metadata: { tanstack: {
+			finishReason: finishReason ?? "stop",
+			...runUsageDetails ? { usage: runUsageDetails } : {}
+		} }
+	};
+}
+function toolResult(toolCallId, output, isError) {
+	return {
+		type: EventType.TOOL_CALL_RESULT,
+		messageId: generateMessageId(),
+		toolCallId,
+		content: JSON.stringify(output ?? null),
+		role: "tool",
+		...isError && { metadata: { tanstack: { state: "output-error" } } }
+	};
+}
+function approvalInterrupt(runId, p) {
+	const id = `approval_${p.toolCallId}`;
+	const normalized = normalizeApprovalSchema(void 0, INPUT_SCHEMA);
+	return {
+		id,
+		reason: "tool_call",
+		message: `Approval required to run ${p.name}`,
+		toolCallId: p.toolCallId,
+		responseSchema: normalized.responseSchema,
+		metadata: {
+			kind: "approval",
+			toolName: p.name,
+			input: p.input,
+			[INTERRUPT_BINDING_METADATA_KEY]: {
+				v: INTERRUPT_BINDING_VERSION,
+				kind: "tool-approval",
+				interruptId: id,
+				toolName: p.name,
+				toolCallId: p.toolCallId,
+				originalArgs: p.input,
+				inputSchemaHash: hashSchemaInput(INPUT_SCHEMA),
+				approvalSchemaHash: normalized.approvalSchemaHash,
+				responseSchemaHash: normalized.responseSchemaHash,
+				interruptedRunId: runId,
+				generation: 0
+			}
+		}
+	};
+}
+function clientToolInterrupt(runId, p) {
+	const id = `client_tool_${p.toolCallId}`;
+	return {
+		id,
+		reason: "tanstack:client_tool_execution",
+		message: `Client tool ${p.name} is ready to run`,
+		toolCallId: p.toolCallId,
+		responseSchema: CLIENT_RESPONSE_SCHEMA,
+		metadata: {
+			kind: "client_tool",
+			toolName: p.name,
+			input: p.input,
+			[INTERRUPT_BINDING_METADATA_KEY]: {
+				v: INTERRUPT_BINDING_VERSION,
+				kind: "client-tool-execution",
+				interruptId: id,
+				toolName: p.name,
+				toolCallId: p.toolCallId,
+				outputSchemaHash: hashSchemaInput(void 0),
+				responseSchemaHash: digestInterruptJson(canonicalInterruptJson(CLIENT_RESPONSE_SCHEMA)),
+				interruptedRunId: runId,
+				generation: 0
+			}
+		}
+	};
+}
+//#endregion
+export { approvalOf, byokMissing, clientResultOf, custom, echo, error, finish, reasoning, respond, scripted, sequence, sleep, structured, text, tool, usage };

package/dist/ollama-BBJs-3mK.mjs

@@ -0,0 +1,80 @@
+import { defineByokProvider } from "@tanstack/ai/byok";
+//#region src/catalog/providers/ollama.ts
+const ollama = {
+	id: "ollama",
+	label: "Ollama",
+	byok: defineByokProvider({
+		id: "ollama",
+		label: "Ollama"
+	}),
+	keyRequired: false,
+	runtime: "local",
+	models: [
+		{
+			id: "llama3.3:latest",
+			name: "Llama 3.3",
+			provider: "ollama",
+			input: ["text"],
+			reasoning: false,
+			contextWindow: 128e3
+		},
+		{
+			id: "qwen3:latest",
+			name: "Qwen3",
+			provider: "ollama",
+			input: ["text"],
+			reasoning: true,
+			contextWindow: 4e4
+		},
+		{
+			id: "gpt-oss:20b",
+			name: "GPT-OSS 20B",
+			provider: "ollama",
+			input: ["text"],
+			reasoning: true,
+			contextWindow: 128e3
+		},
+		{
+			id: "deepseek-r1:latest",
+			name: "DeepSeek R1",
+			provider: "ollama",
+			input: ["text"],
+			reasoning: true,
+			contextWindow: 128e3
+		},
+		{
+			id: "gemma3:latest",
+			name: "Gemma 3",
+			provider: "ollama",
+			input: ["text", "image"],
+			reasoning: false,
+			contextWindow: 128e3
+		},
+		{
+			id: "mistral:latest",
+			name: "Mistral 7B",
+			provider: "ollama",
+			input: ["text"],
+			reasoning: false,
+			contextWindow: 32e3
+		},
+		{
+			id: "phi4:latest",
+			name: "Phi-4",
+			provider: "ollama",
+			input: ["text"],
+			reasoning: false,
+			contextWindow: 16e3
+		},
+		{
+			id: "llava:latest",
+			name: "LLaVA",
+			provider: "ollama",
+			input: ["text", "image"],
+			reasoning: false,
+			contextWindow: 32e3
+		}
+	]
+};
+//#endregion
+export { ollama as t };

package/dist/openai--FIeahIH.mjs

@@ -0,0 +1,153 @@
+import { defineByokProvider } from "@tanstack/ai/byok";
+//#region src/catalog/providers/openai.ts
+const openai = {
+	id: "openai",
+	label: "OpenAI",
+	byok: defineByokProvider({
+		id: "openai",
+		label: "OpenAI",
+		env: "OPENAI_API_KEY"
+	}),
+	keyRequired: true,
+	runtime: "node",
+	models: [
+		{
+			id: "gpt-5.6",
+			name: "GPT-5.6",
+			provider: "openai",
+			input: ["image", "text"],
+			reasoning: true,
+			contextWindow: 105e4,
+			maxOutputTokens: 128e3,
+			cost: {
+				input: 5,
+				output: 30,
+				cacheRead: .5
+			}
+		},
+		{
+			id: "gpt-5.5",
+			name: "GPT-5.5",
+			provider: "openai",
+			input: [
+				"text",
+				"image",
+				"document"
+			],
+			reasoning: true,
+			contextWindow: 105e4,
+			maxOutputTokens: 128e3,
+			cost: {
+				input: 5,
+				output: 30,
+				cacheRead: .5
+			}
+		},
+		{
+			id: "gpt-5.4-mini",
+			name: "GPT-5.4 mini",
+			provider: "openai",
+			input: ["image", "text"],
+			reasoning: true,
+			contextWindow: 4e5,
+			maxOutputTokens: 128e3,
+			cost: {
+				input: .75,
+				output: 4.5,
+				cacheRead: .075
+			}
+		},
+		{
+			id: "gpt-5.2",
+			name: "GPT-5.2",
+			provider: "openai",
+			input: [
+				"text",
+				"image",
+				"document"
+			],
+			reasoning: true,
+			contextWindow: 4e5,
+			maxOutputTokens: 128e3,
+			cost: {
+				input: 1.75,
+				output: 14,
+				cacheRead: .175
+			}
+		},
+		{
+			id: "gpt-5.1",
+			name: "GPT-5.1",
+			provider: "openai",
+			input: [
+				"text",
+				"image",
+				"document"
+			],
+			reasoning: true,
+			contextWindow: 4e5,
+			maxOutputTokens: 128e3,
+			cost: {
+				input: 1.25,
+				output: 10,
+				cacheRead: .125
+			}
+		},
+		{
+			id: "gpt-5",
+			name: "GPT-5",
+			provider: "openai",
+			input: [
+				"text",
+				"image",
+				"document"
+			],
+			reasoning: true,
+			contextWindow: 4e5,
+			maxOutputTokens: 128e3,
+			cost: {
+				input: 1.25,
+				output: 10,
+				cacheRead: .125
+			}
+		},
+		{
+			id: "gpt-4.1",
+			name: "GPT-4.1",
+			provider: "openai",
+			input: [
+				"text",
+				"image",
+				"document"
+			],
+			reasoning: false,
+			contextWindow: 1047576,
+			maxOutputTokens: 32768,
+			cost: {
+				input: 2,
+				output: 8,
+				cacheRead: .5
+			}
+		},
+		{
+			id: "o4-mini",
+			name: "o4-mini",
+			provider: "openai",
+			input: [
+				"text",
+				"image",
+				"document"
+			],
+			reasoning: true,
+			contextWindow: 2e5,
+			maxOutputTokens: 1e5,
+			cost: {
+				input: 1.1,
+				output: 4.4,
+				cacheRead: .275
+			}
+		}
+	]
+};
+//#endregion
+export { openai as t };