@namzu/zen 2.5.0 → 3.0.0

package/src/client.ts

@@ -7,6 +7,7 @@ import {
 	APICallError,
 	type LanguageModelV3,
 	type LanguageModelV3Content,
+	type LanguageModelV3Prompt,
 	type LanguageModelV3StreamPart,
 	type LanguageModelV3Usage,
 	type SharedV3ProviderMetadata,
@@ -31,9 +32,15 @@ import {
 	findZenCatalogueModel,
 	isUnroutedZenModel,
 } from './catalogue/catalogue.js'
+import { isDirectAnonymousZenId } from './catalogue/derive.js'
 import type { ZenModel, ZenService } from './models.js'
 import { createCallOptions } from './options.js'
-import { createReplayState, toReasoningBlocks } from './prompt.js'
+import {
+	createReplayState,
+	isGoDeepSeekV4ResponsesModel,
+	isMuseSparkResponsesModel,
+	toReasoningBlocks,
+} from './prompt.js'
 import type { ZenConfig, ZenGoConfig } from './types.js'
 
 export const ZEN_CAPABILITIES: ProviderCapabilities = {
@@ -50,6 +57,235 @@ export const ZEN_CAPABILITIES: ProviderCapabilities = {
 export const ZEN_BASE_URL = 'https://opencode.ai/zen/v1'
 export const ZEN_GO_BASE_URL = 'https://opencode.ai/zen/go/v1'
 
+function withoutMuseSparkEncryptedReasoning(init?: RequestInit): RequestInit {
+	// The pinned OpenAI adapter adds this include automatically whenever a
+	// reasoning model uses store:false, even if providerOptions omits it.
+	// Muse Spark cannot round-trip that gateway-issued ciphertext. Keep the
+	// request stateless and preserve every other include the adapter may add.
+	if (typeof init?.body !== 'string')
+		throw new Error('Zen Muse Spark adapter emitted a request body that cannot be checked.')
+	const body: unknown = JSON.parse(init.body)
+	if (typeof body !== 'object' || body === null || Array.isArray(body))
+		throw new Error('Zen Muse Spark adapter emitted an invalid request body.')
+	const request = body as Record<string, unknown>
+	if (request.include !== undefined) {
+		if (
+			!Array.isArray(request.include) ||
+			!request.include.every((item) => typeof item === 'string')
+		)
+			throw new Error('Zen Muse Spark adapter emitted an invalid include list.')
+		const include = request.include.filter((item) => item !== 'reasoning.encrypted_content')
+		if (include.length > 0) request.include = include
+		else request.include = undefined
+	}
+	return { ...init, body: JSON.stringify(request) }
+}
+
+function isGoDeepSeekV4ChatModel(service: ZenService, model: string, protocol: string): boolean {
+	return (
+		service === 'go' &&
+		protocol === 'chat' &&
+		(model === 'deepseek-v4-pro' ||
+			model === 'deepseek-v4.1-flash' ||
+			model === 'deepseek-v4-flash')
+	)
+}
+
+function adapterBody(init: RequestInit | undefined, model: string): Record<string, unknown> {
+	if (typeof init?.body !== 'string')
+		throw new Error(`Zen adapter emitted a non-JSON request body for ${model}.`)
+	const body: unknown = JSON.parse(init.body)
+	if (typeof body !== 'object' || body === null || Array.isArray(body))
+		throw new Error(`Zen adapter emitted an invalid request body for ${model}.`)
+	return body as Record<string, unknown>
+}
+
+function withGoDeepSeekV4ChatHistory(init: RequestInit | undefined, model: string): RequestInit {
+	const body = adapterBody(init, model)
+	if (!Array.isArray(body.messages)) throw new Error('Go DeepSeek chat request has no messages.')
+	for (const value of body.messages) {
+		if (typeof value !== 'object' || value === null || Array.isArray(value))
+			throw new Error('Go DeepSeek chat request has an invalid message.')
+		const message = value as Record<string, unknown>
+		if (message.role !== 'assistant') continue
+		if (message.content === null) message.content = ''
+		if (message.reasoning_content === undefined || message.reasoning_content === null)
+			message.reasoning_content = ''
+		else if (typeof message.reasoning_content !== 'string')
+			throw new Error('Go DeepSeek chat request has invalid reasoning content.')
+	}
+	return { ...init, body: JSON.stringify(body) }
+}
+
+function withGoDeepSeekV4ResponsesHistory(
+	init: RequestInit | undefined,
+	model: string,
+	prompt: LanguageModelV3Prompt,
+): RequestInit {
+	const body = adapterBody(init, model)
+	if (!Array.isArray(body.input)) throw new Error('Go DeepSeek Responses request has no input.')
+	const input: Record<string, unknown>[] = []
+	let turn: Record<string, unknown>[] = []
+	const sourceTurns = prompt.filter((message) => message.role === 'assistant')
+	let sourceIndex = 0
+	const refuse = (): never => {
+		throw new ProviderRequestError({
+			providerId: 'zen-go',
+			kind: 'bad_request',
+			detail: `Go DeepSeek ${model} requires captured, nonempty reasoning_text for each previous assistant turn. This history cannot be replayed safely.`,
+		})
+	}
+	const flushTurn = () => {
+		if (turn.length === 0) return
+		const source = sourceTurns[sourceIndex++]
+		if (source?.role !== 'assistant') return refuse()
+		const messages = turn.filter((item) => item.role === 'assistant')
+		const calls = turn.filter((item) => item.type === 'function_call')
+		const sourceText = source.content
+			.filter((part) => part.type === 'text')
+			.map((part) => part.text)
+		const wireText = messages.flatMap((message) =>
+			Array.isArray(message.content)
+				? message.content
+						.filter(
+							(part) => typeof part === 'object' && part !== null && part.type === 'output_text',
+						)
+						.map((part) => part.text)
+				: [],
+		)
+		const sourceCalls = source.content
+			.filter((part) => part.type === 'tool-call')
+			.map((part) => part.toolCallId)
+		const wireCalls = calls.map((call) => call.call_id)
+		if (
+			JSON.stringify(sourceText) !== JSON.stringify(wireText) ||
+			JSON.stringify(sourceCalls) !== JSON.stringify(wireCalls)
+		)
+			refuse()
+		const captured = source.content
+			.filter((part) => part.type === 'reasoning')
+			.map((part) => part.text)
+			.filter((text) => text.trim().length > 0)
+			.join('\n')
+		if (!captured) refuse()
+		const reasoning = {
+			type: 'reasoning',
+			summary: [],
+			content: [{ type: 'reasoning_text', text: captured }],
+		}
+		// The adapter can replay a native [tool-call, text] turn as a call then
+		// an assistant message. Go rejects a message between calls and outputs.
+		input.push(reasoning, ...messages, ...calls)
+		turn = []
+	}
+	for (const value of body.input) {
+		if (typeof value !== 'object' || value === null || Array.isArray(value))
+			throw new Error('Go DeepSeek Responses request has an invalid input item.')
+		const item = value as Record<string, unknown>
+		if (item.type === 'reasoning' || item.type === 'function_call' || item.role === 'assistant') {
+			turn.push(item)
+		} else {
+			flushTurn()
+			input.push(item)
+		}
+	}
+	flushTurn()
+	if (sourceIndex !== sourceTurns.length) refuse()
+	body.input = input
+	return { ...init, body: JSON.stringify(body) }
+}
+
+function withGoDeepSeekReasoningTextEvents(response: Response): Response {
+	if (
+		!response.ok ||
+		!response.body ||
+		!response.headers.get('content-type')?.includes('text/event-stream')
+	)
+		return response
+	// @ai-sdk/openai 3.0.109 understands reasoning summary deltas but not the
+	// reasoning_text delta that Go DeepSeek streams. Translate that one event
+	// before the adapter parses SSE; the original text then enters durable replay.
+	const decoder = new TextDecoder()
+	const encoder = new TextEncoder()
+	let pending = ''
+	const rewrite = (event: string): string => {
+		const lines = event.split(/\r\n|\n|\r/)
+		const dataLines = lines.filter((line) => line.startsWith('data:'))
+		if (dataLines.length !== 1) return event
+		let value: unknown
+		try {
+			value = JSON.parse(dataLines[0]?.slice(5).trimStart() ?? '')
+		} catch {
+			return event
+		}
+		if (
+			typeof value !== 'object' ||
+			value === null ||
+			!('type' in value) ||
+			value.type !== 'response.reasoning_text.delta' ||
+			!('item_id' in value) ||
+			typeof value.item_id !== 'string' ||
+			!('delta' in value) ||
+			typeof value.delta !== 'string'
+		)
+			return event
+		const translated = {
+			...value,
+			type: 'response.reasoning_summary_text.delta',
+			summary_index: 0,
+		}
+		return lines
+			.map((line) => {
+				if (line.startsWith('data:')) return `data: ${JSON.stringify(translated)}`
+				if (line.startsWith('event:')) return 'event: response.reasoning_summary_text.delta'
+				return line
+			})
+			.join('\n')
+	}
+	const body = response.body.pipeThrough(
+		new TransformStream<Uint8Array, Uint8Array>({
+			transform(chunk, controller) {
+				pending += decoder.decode(chunk, { stream: true })
+				while (true) {
+					const boundary = /\r\n\r\n|\n\n|\r\r/.exec(pending)
+					if (!boundary) break
+					const event = pending.slice(0, boundary.index)
+					pending = pending.slice(boundary.index + boundary[0].length)
+					controller.enqueue(encoder.encode(`${rewrite(event)}\n\n`))
+				}
+			},
+			flush(controller) {
+				pending += decoder.decode()
+				if (pending) controller.enqueue(encoder.encode(pending))
+			},
+		}),
+	)
+	const headers = new Headers(response.headers)
+	headers.delete('content-length')
+	headers.delete('content-encoding')
+	return new Response(body, {
+		status: response.status,
+		statusText: response.statusText,
+		headers,
+	})
+}
+
+/**
+ * The words a backend's own finish reason uses, in `LanguageModelV3FinishReason.raw`,
+ * for "the model's context window, not its output-token budget, is what ran
+ * out" — Anthropic's `model_context_window_exceeded` (folded, with
+ * `max_tokens`, into `unified: 'length'` by `@ai-sdk/anthropic`'s
+ * `mapAnthropicStopReason`) and the words other OpenAI-compatible backends
+ * use (see `@namzu/http`'s `mapOpenAIFinish`), since Zen also routes through
+ * `@ai-sdk/openai-compatible`.
+ */
+const CONTEXT_WINDOW_RAW_FINISH_REASONS = new Set([
+	'model_context_window_exceeded',
+	'model_length',
+	'context_length',
+	'context_length_exceeded',
+])
+
 /** A provider instance belongs to one conversation; it never owns an agent loop. */
 export class ZenProvider implements LLMProvider {
 	readonly id: 'zen' | 'zen-go'
@@ -119,12 +355,13 @@ export class ZenProvider implements LLMProvider {
 
 	async *chatStream(params: ChatCompletionParams): AsyncIterable<StreamChunk> {
 		const model =
-			params.model ||
-			this.config.model ||
-			(this.anonymous ? 'muse-spark-1.3-contributor-free' : 'glm-5.3-flash')
+			params.model || this.config.model || (this.anonymous ? 'space-bunny-free' : 'glm-5.3-flash')
 		const catalogue = this.runtimeCatalogue()
 		const info = findZenCatalogueModel(catalogue, this.service, model)
-		if (this.anonymous && info?.supportsAnonymousAccess !== true)
+		if (
+			this.anonymous &&
+			(!isDirectAnonymousZenId(model) || info?.supportsAnonymousAccess !== true)
+		)
 			throw new ProviderRequestError({
 				providerId: this.id,
 				kind: 'auth',
@@ -140,7 +377,11 @@ export class ZenProvider implements LLMProvider {
 					? 'The service serves this model, but no source states its wire format. Configure protocol explicitly.'
 					: 'This model has no known wire format. Update the provider or configure protocol explicitly.',
 			})
-		const route = params.providerRoute ?? { providerId: this.id, model, chainIndex: 0 }
+		const route = params.providerRoute ?? {
+			providerId: this.id,
+			model,
+			chainIndex: 0,
+		}
 		const controller = new AbortController()
 		const signal = AbortSignal.any([
 			controller.signal,
@@ -152,7 +393,7 @@ export class ZenProvider implements LLMProvider {
 			signal.throwIfAborted()
 			let options: ReturnType<typeof createCallOptions>
 			try {
-				options = createCallOptions({ ...params, model }, route, this.service, protocol)
+				options = createCallOptions({ ...params, model }, route, this.service, protocol, info)
 			} catch (error) {
 				if (isProviderRequestError(error)) throw error
 				throw new ProviderRequestError({
@@ -177,8 +418,20 @@ export class ZenProvider implements LLMProvider {
 						body.generationConfig ??= {}
 						delete body.generationConfig.responseSchema
 						body.generationConfig.responseJsonSchema = params.responseFormat.json_schema.schema
-						return this.requestFetch(input, { ...init, body: JSON.stringify(body) })
+						return this.requestFetch(input, {
+							...init,
+							body: JSON.stringify(body),
+						})
 					}
+					if (isMuseSparkResponsesModel(model, protocol))
+						return this.requestFetch(input, withoutMuseSparkEncryptedReasoning(init))
+					if (isGoDeepSeekV4ChatModel(this.service, model, protocol))
+						return this.requestFetch(input, withGoDeepSeekV4ChatHistory(init, model))
+					if (isGoDeepSeekV4ResponsesModel(this.service, model, protocol))
+						return this.requestFetch(
+							input,
+							withGoDeepSeekV4ResponsesHistory(init, model, options.prompt),
+						).then(withGoDeepSeekReasoningTextEvents)
 					return this.requestFetch(input, init)
 				}) as typeof fetch,
 			}
@@ -209,7 +462,10 @@ export class ZenProvider implements LLMProvider {
 			const texts = new Map<string, Extract<LanguageModelV3Content, { type: 'text' }>>()
 			const thoughts = new Map<
 				string,
-				{ index: number; value: Extract<LanguageModelV3Content, { type: 'reasoning' }> }
+				{
+					index: number
+					value: Extract<LanguageModelV3Content, { type: 'reasoning' }>
+				}
 			>()
 			const tools = new Map<
 				string,
@@ -274,7 +530,10 @@ export class ZenProvider implements LLMProvider {
 						const index = thoughts.size
 						thoughts.set(part.id, { index, value })
 						content.push(value)
-						yield { id, delta: { reasoning: { index, type: 'thinking', text: '' } } }
+						yield {
+							id,
+							delta: { reasoning: { index, type: 'thinking', text: '' } },
+						}
 						break
 					}
 					case 'reasoning-delta':
@@ -342,7 +601,9 @@ export class ZenProvider implements LLMProvider {
 						)
 						yield {
 							id,
-							delta: { toolCalls: [{ index: tool.index, function: { arguments: part.delta } }] },
+							delta: {
+								toolCalls: [{ index: tool.index, function: { arguments: part.delta } }],
+							},
 						}
 						break
 					}
@@ -361,7 +622,12 @@ export class ZenProvider implements LLMProvider {
 							throw new Error('Provider-executed tools are not configured.')
 						let tool = tools.get(part.toolCallId)
 						if (!tool) {
-							tool = { index: tools.size, input: '', ended: false, value: { ...part } }
+							tool = {
+								index: tools.size,
+								input: '',
+								ended: false,
+								value: { ...part },
+							}
 							tools.set(part.toolCallId, tool)
 							content.push(tool.value)
 							yield {
@@ -385,7 +651,9 @@ export class ZenProvider implements LLMProvider {
 						if (suffix)
 							yield {
 								id,
-								delta: { toolCalls: [{ index: tool.index, function: { arguments: suffix } }] },
+								delta: {
+									toolCalls: [{ index: tool.index, function: { arguments: suffix } }],
+								},
 							}
 						tool.value.input = part.input
 						tool.value.providerMetadata = mergeMetadata(
@@ -393,7 +661,12 @@ export class ZenProvider implements LLMProvider {
 							part.providerMetadata,
 						)
 						tool.ended = true
-						yield { id, delta: { toolCallEnd: { index: tool.index, id: part.toolCallId } } }
+						yield {
+							id,
+							delta: {
+								toolCallEnd: { index: tool.index, id: part.toolCallId },
+							},
+						}
 						break
 					}
 					case 'finish':
@@ -423,6 +696,11 @@ export class ZenProvider implements LLMProvider {
 				id,
 				delta: {},
 				finishReason,
+				...(finishReason === 'length' &&
+				finish.finishReason.raw &&
+				CONTEXT_WINDOW_RAW_FINISH_REASONS.has(finish.finishReason.raw)
+					? { finishDetail: 'context_window' as const }
+					: {}),
 				usage: mapUsage(finish.usage),
 				replayState: createReplayState(
 					{ ...params, model },
@@ -472,7 +750,11 @@ export class ZenProvider implements LLMProvider {
 				seen.add(item.id)
 				const model = findZenCatalogueModel(catalogue, this.service, item.id)
 				if (model) {
-					if (!this.anonymous || model.supportsAnonymousAccess === true) result.push({ ...model })
+					if (
+						!this.anonymous ||
+						(isDirectAnonymousZenId(item.id) && model.supportsAnonymousAccess === true)
+					)
+						result.push({ ...model })
 					continue
 				}
 				// Served, and named by the runtime catalogue as having no known wire:
@@ -582,7 +864,13 @@ export class ZenProvider implements LLMProvider {
 		const envelope = safeErrorEnvelope(error)
 		const body = scrub(JSON.stringify(envelope))
 		if (envelope.status !== undefined)
-			return named(providerHttpError({ providerId: this.id, status: envelope.status, body }))
+			return named(
+				providerHttpError({
+					providerId: this.id,
+					status: envelope.status,
+					body,
+				}),
+			)
 		return named(
 			providerVendorError({
 				providerId: this.id,

package/src/models.review.json

@@ -1,7 +1,8 @@
 {
 	"omissions": {
 		"go/deepseek-flash": "Served by the Go service and named by no route row on either page; models.dev carries no entry for it either, so neither a wire nor its limits can be derived.",
-		"go/glm-5": "Served by Go and no longer routed by the Go page, which routes GLM 5.1, 5.2, 5.3 and 5.3 Flash. The Zen page still routes this id, and one service's route is not the other's, so none is taken from it.",
+		"go/glm-5": "Served by Go and no longer routed by the Go page, which routes GLM 5.2, 5.3 and 5.3 Flash. The Zen page still routes this id, and one service's route is not the other's, so none is taken from it.",
+		"go/glm-5.1": "Still served by Go, but the current Go page states neither a route nor a price for it. The /models answer states no wire, so the old bundled route is not carried without current evidence.",
 		"go/grok-4.5": "Served by Go and absent from the Go page, which routes Grok 4.6. models.dev states an npm package for it, and that field is deliberately not used as a route, so none is carried.",
 		"go/hy3-preview": "Served by Go and named by no route row on either page; models.dev carries no entry for it, so neither a wire nor its limits can be derived.",
 		"go/kimi-k2.5": "Served by Go and absent from the Go page, which routes Kimi K2.6, K2.7 Code and K3. The Zen page still routes this id, and one service's route is not the other's, so none is taken from it.",
@@ -11,7 +12,9 @@
 		"go/mimo-v2.6-pro": "Routed by the Go page since 2026-09-21, and models.dev carries no `opencode-go` entry for it yet, so its limits cannot be derived and it is not carried.",
 		"go/minimax-m2.5": "Superseded on Go by MiniMax M2.7 and M3, which are both carried. The page still lists it.",
 		"go/omen-alpha": "Served by Go and no longer routed by the Go page, which is why this release dropped it from the catalogue. No source states a wire for it any more, so a caller that needs it must name the protocol itself.",
-		"go/qwen3.5-plus": "Served by Go and absent from the Go page, which routes Qwen 3.6 Plus and later. The Zen page routes this id on Messages, and one service's route is not the other's, so none is taken from it.",
+		"go/qwen3.5-plus": "Served by Go and absent from the Go page, which routes Qwen 3.7 Plus, 3.8 Flash and 3.8 Max. The Zen page routes this id on Messages, and one service's route is not the other's, so none is taken from it.",
+		"go/qwen3.6-plus": "Still served by Go, but the current Go page states neither a route nor a price for it. The /models answer states no wire, and the old bundled Messages route conflicts with the reference client's Chat route, so it is not carried by guessing.",
+		"go/qwen3.7-max": "Still served by Go, but the current Go page states neither a route nor a price for it. The /models answer states no wire, so the old bundled route is not carried without current evidence.",
 		"zen/claude-sonnet-4": "Served by Zen and named by no route row on either page: the Zen page routes Claude Sonnet 4.5 and 4.6. models.dev states an npm package for it, and that field is deliberately not used as a route, so none is carried.",
 		"zen/deepseek-v4-flash-free": "Served by Zen and absent from the Zen page, which routes DeepSeek V4 Flash. models.dev states a name and limits for this free id and no wire, so none is carried.",
 		"zen/glm-5": "Superseded by GLM 5.1, 5.2 and 5.3, which are all carried. The page still lists it.",