@namzu/zen 2.5.2 → 3.1.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,21 @@ import {
 	findZenCatalogueModel,
 	isUnroutedZenModel,
 } from './catalogue/catalogue.js'
+import { isDirectAnonymousZenId } from './catalogue/derive.js'
+import { isExperimentalFreeZenModel } from './catalogue/experimental-free.js'
+import {
+	EXPERIMENTAL_OPENCODE_USER_AGENT,
+	experimentalOpenCodeRequestId,
+	experimentalOpenCodeSessionId,
+} from './experimental-identity.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 +63,219 @@ 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
@@ -74,7 +300,11 @@ export class ZenProvider implements LLMProvider {
 	readonly sessionId: string
 	private readonly baseURL: string
 	private readonly timeout: number
-	private readonly requestFetch: typeof fetch
+	private readonly requestFetch: (
+		input: Parameters<typeof fetch>[0],
+		init?: RequestInit,
+		overrides?: Readonly<Record<string, string>>,
+	) => ReturnType<typeof fetch>
 	private readonly apiKey: string
 	private readonly anonymous: boolean
 
@@ -125,27 +355,31 @@ export class ZenProvider implements LLMProvider {
 		this.timeout = config.timeout ?? 120_000
 		if (!Number.isSafeInteger(this.timeout) || this.timeout <= 0)
 			throw new Error('timeout must be a positive integer in milliseconds.')
-		this.requestFetch = (input, init) => {
+		this.requestFetch = (input, init, overrides) => {
 			const headers = new Headers(init?.headers)
 			for (const [key, value] of Object.entries(attributionHeaders())) headers.set(key, value)
 			headers.set('x-opencode-session', this.sessionId)
+			if (overrides) for (const [key, value] of Object.entries(overrides)) headers.set(key, value)
 			return fetch(input, { ...init, headers, redirect: 'error' })
 		}
 	}
 
 	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)
+		const verifiedAnonymous =
+			isDirectAnonymousZenId(model) &&
+			info?.supportsAnonymousAccess === true &&
+			isExperimentalFreeZenModel(this.service, info)
+		const experimentalAnonymous = isExperimentalFreeZenModel(this.service, info)
+		if (this.anonymous && !verifiedAnonymous && !experimentalAnonymous)
 			throw new ProviderRequestError({
 				providerId: this.id,
 				kind: 'auth',
 				detail:
-					'Anonymous Zen access requires a supported free model. Configure an API key for other models.',
+					'Anonymous Zen access requires a listed free model with a known route. Configure an API key for other models.',
 			})
 		const protocol = this.config.protocol ?? info?.protocol
 		if (!protocol)
@@ -156,7 +390,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,
@@ -164,11 +402,28 @@ export class ZenProvider implements LLMProvider {
 			...(params.signal ? [params.signal] : []),
 		])
 		let reader: ReadableStreamDefaultReader<LanguageModelV3StreamPart> | undefined
+		const experimentalHeaders =
+			this.anonymous && experimentalAnonymous && !verifiedAnonymous && this.baseURL === ZEN_BASE_URL
+				? {
+						'User-Agent': EXPERIMENTAL_OPENCODE_USER_AGENT,
+						'x-opencode-client': 'cli',
+						'x-opencode-project': 'global',
+						'x-opencode-session': experimentalOpenCodeSessionId(this.sessionId),
+					}
+				: undefined
+		const modelFetch: typeof fetch = (input, init) =>
+			this.requestFetch(
+				input,
+				init,
+				experimentalHeaders
+					? { ...experimentalHeaders, 'x-opencode-request': experimentalOpenCodeRequestId() }
+					: undefined,
+			)
 		try {
 			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({
@@ -193,9 +448,21 @@ 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 modelFetch(input, {
+							...init,
+							body: JSON.stringify(body),
+						})
 					}
-					return this.requestFetch(input, init)
+					if (isMuseSparkResponsesModel(model, protocol))
+						return modelFetch(input, withoutMuseSparkEncryptedReasoning(init))
+					if (isGoDeepSeekV4ChatModel(this.service, model, protocol))
+						return modelFetch(input, withGoDeepSeekV4ChatHistory(init, model))
+					if (isGoDeepSeekV4ResponsesModel(this.service, model, protocol))
+						return modelFetch(
+							input,
+							withGoDeepSeekV4ResponsesHistory(init, model, options.prompt),
+						).then(withGoDeepSeekReasoningTextEvents)
+					return modelFetch(input, init)
 				}) as typeof fetch,
 			}
 			let native: LanguageModelV3
@@ -225,7 +492,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,
@@ -290,7 +560,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':
@@ -358,7 +631,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
 					}
@@ -377,7 +652,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 {
@@ -401,7 +681,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(
@@ -409,7 +691,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':
@@ -493,7 +780,8 @@ 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 || isExperimentalFreeZenModel(this.service, model))
+						result.push({ ...model })
 					continue
 				}
 				// Served, and named by the runtime catalogue as having no known wire:
@@ -603,7 +891,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/experimental-identity.ts

@@ -0,0 +1,34 @@
+import { createHash, randomBytes } from 'node:crypto'
+
+const ALPHABET = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
+
+/** Pinned to the OpenCode request shape observed in the 2026-09-28 trial. */
+export const EXPERIMENTAL_OPENCODE_USER_AGENT =
+	'opencode/1.18.32 ai-sdk/provider-utils/4.0.23 runtime/bun/1.3.14'
+
+function timeHex(value: bigint): string {
+	const time = Buffer.alloc(6)
+	for (let index = 0; index < time.length; index++) {
+		time[index] = Number((value >> BigInt(40 - index * 8)) & 0xffn)
+	}
+	return time.toString('hex')
+}
+
+function base62(bytes: Uint8Array): string {
+	return Array.from(bytes, (byte) => ALPHABET[byte % ALPHABET.length]).join('')
+}
+
+/** Stable when the CLI constructs a new provider for each turn of one conversation. */
+export function experimentalOpenCodeSessionId(namzuSessionId: string): string {
+	const hash = createHash('sha256').update(namzuSessionId).digest()
+	const uuidTime = /^([0-9a-f]{8})-([0-9a-f]{4})-7[0-9a-f]{3}-/i.exec(namzuSessionId)
+	const milliseconds = uuidTime
+		? BigInt(`0x${uuidTime[1]}${uuidTime[2]}`)
+		: BigInt(`0x${hash.subarray(0, 6).toString('hex')}`)
+	return `ses_${timeHex(~(milliseconds * 0x1000n + 1n))}${base62(hash.subarray(6, 20))}`
+}
+
+/** One OpenCode-shaped message id per outbound model request. */
+export function experimentalOpenCodeRequestId(): string {
+	return `msg_${timeHex(BigInt(Date.now()) * 0x1000n + 1n)}${base62(randomBytes(14))}`
+}

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.",