pi-free 2.2.4 → 2.2.6

package/providers/qoder/stream.ts

@@ -1,15 +1,15 @@
 /**
  * Qoder custom streaming handler.
  *
- * Qoder's API is NOT OpenAI-compatible — it uses a proprietary protocol at
- * `api3.qoder.sh/algo/api/v2/service/pro/sse/agent_chat_generation` with
- * COSY-signed headers, WAF-encoded bodies, and a custom SSE event format.
+ * Qoder's current production API is OpenAI-compatible and lives at
+ * `api2-v2.qoder.sh/model/v1/chat/completions` with standard Bearer auth.
+ * The legacy proprietary SSE/protocol endpoint at api3.qoder.sh has been
+ * decommissioned and returns 500 Internal Server Error.
  *
- * This module implements the full `streamSimple` interface that Pi expects,
- * bridging Qoder's proprietary streaming to Pi's `AssistantMessageEventStream`.
+ * This module implements the `streamSimple` interface that Pi expects,
+ * translating Qoder's response format to Pi's `AssistantMessageEventStream`.
  */
 
-import crypto from "node:crypto";
 import type {
 	Api,
 	AssistantMessage,
@@ -17,19 +17,21 @@ import type {
 	Context,
 	Model,
 	SimpleStreamOptions,
+	StopReason,
 	TextContent,
 	ThinkingContent,
 	ToolCall,
 } from "@earendil-works/pi-ai";
 import * as PiAi from "@earendil-works/pi-ai";
-import { buildAuthHeaders, getMachineId } from "./cosy.ts";
-import { getCachedModelConfig } from "./models.ts";
-import { getCachedCredentials } from "./auth.ts";
-import { qoderEncodeBody } from "./encoding.ts";
+import { BASE_URL_QODER } from "../../constants.ts";
+import { createLogger } from "../../lib/logger.ts";
+import { getCachedModelConfig, staticModels } from "./models.ts";
 import { ThinkingTagParser } from "./thinking-parser.ts";
 import { transformMessagesForQoder, transformTools } from "./transform.ts";
 
-// ─── Helpers ─────────────────────────────────────────────────────────────────
+// =============================================================================
+// Helpers / State
+// =============================================================================
 
 interface ToolCallState {
 	arguments: string;
@@ -47,52 +49,12 @@ interface StreamState {
 	thinkingBlockIndex: number;
 	toolCallsState: ToolCallState[];
 	thinkingParser: ThinkingTagParser | null;
+	hasReasoningContent: boolean;
 }
 
-function stableHash(prefix: string, ...inputs: string[]): string {
-	const hash = crypto.createHash("sha256");
-	hash.update(prefix);
-	for (const input of inputs) {
-		hash.update("\0");
-		hash.update(input);
-	}
-	return hash.digest("hex").slice(0, 16);
-}
-
-function stableChatRecordID(
-	model: string,
-	messages: Array<{ role?: string; content?: unknown }>,
-	tools: unknown,
-	maxTokens: number,
-): string {
-	const hash = crypto.createHash("sha256");
-	hash.update("qoder-record");
-	hash.update("\0");
-	hash.update(model);
-	for (const msg of messages) {
-		if (msg?.role) {
-			hash.update("\0");
-			hash.update(msg.role);
-		}
-		if (msg?.content) {
-			hash.update("\0");
-			hash.update(
-				typeof msg.content === "string"
-					? msg.content
-					: JSON.stringify(msg.content),
-			);
-		}
-	}
-	if (tools) {
-		hash.update("\0");
-		hash.update(JSON.stringify(tools));
-	}
-	hash.update("\0");
-	hash.update(`mt=${maxTokens}`);
-	return hash.digest("hex").slice(0, 16);
-}
-
-// ─── Delta processing helpers ────────────────────────────────────────────────
+// =============================================================================
+// Delta processing
+// =============================================================================
 
 function processReasoningDelta(
 	state: StreamState,
@@ -134,7 +96,7 @@ function closeThinkingBlock(state: StreamState): void {
 }
 
 function processTextDelta(state: StreamState, text: string): void {
-	if (state.thinkingParser) {
+	if (state.thinkingParser && !state.hasReasoningContent) {
 		state.thinkingParser.processChunk(text);
 		return;
 	}
@@ -210,8 +172,9 @@ function processDelta(
 	state: StreamState,
 	delta: Record<string, unknown>,
 ): void {
-	// 1. Reasoning content (API-native)
+	// 1. Reasoning content (API-native OpenAI-compatible extension)
 	if (delta.reasoning_content) {
+		state.hasReasoningContent = true;
 		processReasoningDelta(state, delta.reasoning_content as string);
 	}
 
@@ -256,40 +219,42 @@ function finalizeToolCalls(state: StreamState): void {
 	}
 }
 
-// ─── SSE parsing ─────────────────────────────────────────────────────────────
+// =============================================================================
+// SSE parsing (OpenAI-compatible stream)
+// =============================================================================
 
-function handleSSELine(
-	state: StreamState,
-	line: string,
-): boolean {
+function handleSSELine(state: StreamState, line: string): boolean {
 	if (!line.startsWith("data:")) return false;
 
 	const dataStr = line.slice(5).trim();
 	if (dataStr === "[DONE]") return true;
 
+	let parsed: Record<string, unknown>;
 	try {
-		const envelope = JSON.parse(dataStr);
-		if (envelope.statusCodeValue && envelope.statusCodeValue !== 200) {
-			throw new Error(
-				`Upstream status ${envelope.statusCodeValue}: ${envelope.body}`,
-			);
-		}
+		parsed = JSON.parse(dataStr);
+	} catch {
+		// Skip unparseable SSE lines
+		return false;
+	}
 
-		const innerStr = envelope.body;
-		if (!innerStr || innerStr === "[DONE]") return false;
+	if (parsed.error) {
+		throw new Error(
+			`Qoder SSE error: ${(parsed.error as { message?: string }).message || JSON.stringify(parsed.error)}`,
+		);
+	}
 
-		const inner = JSON.parse(innerStr);
-		if (inner.choices && inner.choices.length > 0) {
-			const choice = inner.choices[0];
-			if (choice.delta) {
-				processDelta(state, choice.delta);
-			}
-			if (choice.finish_reason) {
-				state.output.stopReason = choice.finish_reason;
-			}
+	if (
+		parsed.choices &&
+		Array.isArray(parsed.choices) &&
+		parsed.choices.length > 0
+	) {
+		const choice = parsed.choices[0] as Record<string, unknown>;
+		if (choice.delta) {
+			processDelta(state, choice.delta as Record<string, unknown>);
+		}
+		if (choice.finish_reason) {
+			state.output.stopReason = choice.finish_reason as StopReason;
 		}
-	} catch {
-		// Skip unparseable SSE lines
 	}
 	return false;
 }
@@ -307,6 +272,12 @@ async function consumeSSEStream(
 
 		buffer += decoder.decode(value, { stream: true });
 
+		if (buffer.length > MAX_SSE_BUFFER_BYTES) {
+			throw new Error(
+				`Qoder SSE buffer exceeded ${MAX_SSE_BUFFER_BYTES} bytes without a newline; stream appears malformed.`,
+			);
+		}
+
 		while (true) {
 			const lineEnd = buffer.indexOf("\n");
 			if (lineEnd === -1) break;
@@ -320,115 +291,146 @@ async function consumeSSEStream(
 	}
 }
 
-// ─── Request builder ─────────────────────────────────────────────────────────
+// =============================================================================
+// Request builder (OpenAI-compatible)
+// =============================================================================
 
-async function fetchQoderStream(
-	setup: StreamSetup,
-	signal?: AbortSignal,
-): Promise<ReadableStream<Uint8Array>> {
-	const {
+const QODER_CHAT_URL = `${BASE_URL_QODER}/model/v1/chat/completions`;
+
+const logger = createLogger("qoder");
+
+/** Max SSE line buffer size before we treat the stream as malformed. */
+const MAX_SSE_BUFFER_BYTES = 1024 * 1024; // 1 MB
+
+/** Redact a bearer token so it never leaks into logs or error messages. */
+function redactToken(token: string | undefined): string {
+	if (!token) return "(none)";
+	if (token.length <= 8) return "***";
+	return `${token.slice(0, 3)}...${token.slice(-3)}`;
+}
+
+interface StreamSetup {
+	accessToken: string;
+	qoderModel: string;
+	modelConfig: Record<string, unknown>;
+	normalizedMessages: unknown[];
+	systemText: string;
+	maxTokens: number;
+	toolsRaw: unknown;
+}
+
+function buildStreamSetup(
+	model: Model<Api>,
+	context: Context,
+	options: SimpleStreamOptions | undefined,
+): StreamSetup {
+	const accessToken = options?.apiKey;
+	if (!accessToken) {
+		throw new Error(
+			"Qoder credentials not set. Run /login qoder or set QODER_PERSONAL_ACCESS_TOKEN.",
+		);
+	}
+
+	// Log for diagnostics (visible in pi output)
+	const isDebug = process.env.QODER_DEBUG === "1";
+
+	const qoderModel = model.id;
+	const modelConfig = getCachedModelConfig(qoderModel) || {
+		key: qoderModel,
+		is_reasoning: isReasoningModel(qoderModel),
+		max_output_tokens: 32768,
+		source: "system",
+	};
+
+	const maxOutputTokens = (modelConfig.max_output_tokens as number) || 32768;
+
+	let normalizedMessages = transformMessagesForQoder(context.messages);
+	const systemText = context.systemPrompt || "";
+
+	// Prepend system prompt as a system message if present.
+	if (systemText) {
+		normalizedMessages = [
+			{ role: "system", content: systemText },
+			...normalizedMessages,
+		];
+	}
+
+	const maxTokens = resolveMaxTokens(maxOutputTokens, options?.maxTokens);
+
+	const toolsRaw =
+		context.tools && context.tools.length > 0
+			? transformTools(context.tools)
+			: undefined;
+
+	if (isDebug) {
+		logger.info("[QODER] streaming request", {
+			endpoint: QODER_CHAT_URL,
+			model: qoderModel,
+			messages: normalizedMessages.length,
+			token: redactToken(accessToken),
+		});
+	}
+
+	return {
 		accessToken,
 		qoderModel,
 		modelConfig,
 		normalizedMessages,
-		lastUserText,
 		systemText,
 		maxTokens,
 		toolsRaw,
-		recordID,
-		userID,
-		name,
-		email,
-		machineID,
-	} = setup;
-	const sessionID = stableHash("qoder-session", userID, qoderModel);
+	};
+}
 
-	const isReasoning = Boolean(modelConfig.is_reasoning);
+async function fetchQoderStream(
+	setup: StreamSetup,
+	signal?: AbortSignal,
+): Promise<ReadableStream<Uint8Array>> {
+	const { accessToken, qoderModel, normalizedMessages, maxTokens, toolsRaw } =
+		setup;
 
 	const reqBody: Record<string, unknown> = {
-		request_id: crypto.randomUUID(),
-		request_set_id: recordID,
-		chat_record_id: recordID,
-		session_id: sessionID,
-		stream: true,
-		chat_task: "FREE_INPUT",
-		is_reply: true,
-		is_retry: false,
-		source: 1,
-		version: "3",
-		session_type: "qodercli",
-		agent_id: "agent_common",
-		task_id: "common",
-		code_language: "",
-		chat_prompt: "",
-		image_urls: null,
-		aliyun_user_type: "",
-		system: systemText,
+		model: qoderModel,
 		messages: normalizedMessages,
-		tools: toolsRaw || [],
-		parameters: { max_tokens: maxTokens },
-		chat_context: {
-			chatPrompt: "",
-			imageUrls: null,
-			extra: {
-				context: [],
-				modelConfig: {
-					key: qoderModel,
-					is_reasoning: isReasoning,
-				},
-				originalContent: lastUserText,
-			},
-			features: [],
-			text: lastUserText,
-		},
-		model_config: modelConfig,
-		business: {
-			product: "cli",
-			version: "1.0.0",
-			type: "agent",
-			stage: "start",
-			id: crypto.randomUUID(),
-			name: lastUserText.substring(0, 30),
-			begin_at: Date.now(),
-		},
+		stream: true,
 	};
 
-	const bodyBytes = Buffer.from(JSON.stringify(reqBody));
-	const encodedBody = qoderEncodeBody(bodyBytes);
-	const encodedBytes = Buffer.from(encodedBody, "utf8");
-
-	const chatURL =
-		"https://api3.qoder.sh/algo/api/v2/service/pro/sse/agent_chat_generation?FetchKeys=llm_model_result&AgentId=agent_common&Encode=1";
+	if (toolsRaw && Array.isArray(toolsRaw) && toolsRaw.length > 0) {
+		reqBody.tools = toolsRaw;
+	}
 
-	const headers = buildAuthHeaders(encodedBytes, chatURL, {
-		userID,
-		authToken: accessToken,
-		name,
-		email,
-		machineID,
-	});
+	if (maxTokens > 0) {
+		reqBody.max_tokens = maxTokens;
+	}
 
-	const modelSource = modelConfig.source || "system";
+	const headers: Record<string, string> = {
+		"Content-Type": "application/json",
+		Accept: "text/event-stream",
+		Authorization: `Bearer ${accessToken}`,
+		"User-Agent": "pi-free-providers",
+	};
 
-	const response = await fetch(chatURL, {
+	const response = await fetch(QODER_CHAT_URL, {
 		method: "POST",
-		headers: {
-			"Content-Type": "application/json",
-			Accept: "text/event-stream",
-			"Cache-Control": "no-cache",
-			"Accept-Encoding": "identity",
-			"X-Model-Key": qoderModel,
-			"X-Model-Source": modelSource as string,
-			...headers,
-		},
-		body: encodedBytes,
+		headers,
+		body: Buffer.from(JSON.stringify(reqBody)),
 		signal,
 	});
 
 	if (!response.ok) {
 		const errText = await response.text();
+		const truncated =
+			errText.length > 500 ? `${errText.slice(0, 500)}...` : errText;
+		logger.error("[QODER] API request failed", {
+			status: response.status,
+			statusText: response.statusText,
+			model: qoderModel,
+			responseLength: errText.length,
+			response: truncated,
+			token: redactToken(accessToken),
+		});
 		throw new Error(
-			`Qoder API request failed: ${response.status} ${response.statusText}. Response: ${errText}`,
+			`Qoder API request failed: ${response.status} ${response.statusText} at ${QODER_CHAT_URL}. Model: ${qoderModel}.`,
 		);
 	}
 
@@ -437,12 +439,10 @@ async function fetchQoderStream(
 	return body;
 }
 
-// ─── Stream handler ──────────────────────────────────────────────────────────
+// =============================================================================
+// Stream handler (Pi `streamSimple` implementation)
+// =============================================================================
 
-/**
- * Main streaming handler for Qoder API requests.
- * This is passed as the `streamSimple` option in `pi.registerProvider`.
- */
 export function streamQoder(
 	model: Model<Api>,
 	context: Context,
@@ -485,85 +485,6 @@ export function streamQoder(
 	return stream;
 }
 
-interface StreamSetup {
-	accessToken: string;
-	qoderModel: string;
-	modelConfig: Record<string, unknown>;
-	normalizedMessages: unknown[];
-	lastUserText: string;
-	systemText: string;
-	maxTokens: number;
-	toolsRaw: unknown;
-	recordID: string;
-	userID: string;
-	name: string;
-	email: string;
-	machineID: string;
-}
-
-function buildStreamSetup(
-	model: Model<Api>,
-	context: Context,
-	options: SimpleStreamOptions | undefined,
-): StreamSetup {
-	const accessToken = options?.apiKey;
-	if (!accessToken) {
-		throw new Error(
-			"Qoder credentials not set. Run /login qoder or set QODER_PERSONAL_ACCESS_TOKEN.",
-		);
-	}
-
-	const cachedCreds = getCachedCredentials();
-	const userID = cachedCreds?.userID || "qoder-user";
-	const name = cachedCreds?.name || "Qoder User";
-	const email = cachedCreds?.email || "user@qoder.com";
-	const machineID = cachedCreds?.machineID || getMachineId();
-
-	const qoderModel = model.id;
-	const modelConfig = getCachedModelConfig(qoderModel) || {
-		key: qoderModel,
-		is_reasoning: isReasoningModel(qoderModel),
-		max_output_tokens: 32768,
-		source: "system",
-	};
-	modelConfig.key = qoderModel;
-
-	const maxOutputTokens = modelConfig.max_output_tokens || 32768;
-
-	const normalizedMessages = transformMessagesForQoder(context.messages);
-	const systemText = context.systemPrompt || "";
-	const lastUserText = extractLastUserText(normalizedMessages);
-
-	const maxTokens = resolveMaxTokens(maxOutputTokens, options?.maxTokens);
-
-	const toolsRaw =
-		context.tools && context.tools.length > 0
-			? transformTools(context.tools)
-			: undefined;
-	const recordID = stableChatRecordID(
-		qoderModel,
-		normalizedMessages,
-		toolsRaw,
-		maxTokens,
-	);
-
-	return {
-		accessToken,
-		qoderModel,
-		modelConfig,
-		normalizedMessages,
-		lastUserText,
-		systemText,
-		maxTokens,
-		toolsRaw,
-		recordID,
-		userID,
-		name,
-		email,
-		machineID,
-	};
-}
-
 async function runStream(
 	output: AssistantMessage,
 	stream: AssistantMessageEventStream,
@@ -586,12 +507,13 @@ async function runStream(
 			thinkingBlockIndex: -1,
 			toolCallsState: [],
 			thinkingParser,
+			hasReasoningContent: false,
 		};
 
 		stream.push({ type: "start", partial: output });
 
-		const reader = await fetchQoderStream(setup, options?.signal).then(
-			(s) => s.getReader(),
+		const reader = await fetchQoderStream(setup, options?.signal).then((s) =>
+			s.getReader(),
 		);
 
 		await consumeSSEStream(state, reader);
@@ -635,30 +557,16 @@ async function runStream(
 	}
 }
 
-// ─── Small pure helpers ──────────────────────────────────────────────────────
+// =============================================================================
+// Small pure helpers
+// =============================================================================
 
-function isReasoningModel(modelId: string): boolean {
-	return (
-		modelId === "ultimate" ||
-		modelId === "performance" ||
-		modelId.includes("dmodel") ||
-		modelId.includes("dfmodel")
-	);
-}
+const REASONING_MODEL_IDS = new Set(
+	staticModels.filter((m) => m.reasoning).map((m) => m.id),
+);
 
-function extractLastUserText(
-	messages: Array<{ role?: string; content?: unknown }>,
-): string {
-	for (let i = messages.length - 1; i >= 0; i--) {
-		const msg = messages[i];
-		if (msg?.role !== "user") continue;
-		const content = msg.content;
-		if (typeof content === "string") return content;
-		if (Array.isArray(content)) {
-			return content.map((c) => ("text" in c ? c.text : "")).join("");
-		}
-	}
-	return "";
+function isReasoningModel(modelId: string): boolean {
+	return REASONING_MODEL_IDS.has(modelId);
 }
 
 function resolveMaxTokens(maxOutputTokens: number, requested?: number): number {

package/providers/qoder/transform.ts

@@ -41,7 +41,7 @@ type QoderContent = string | Array<QoderTextPart | QoderImagePart>;
 
 /** OpenAI-style message sent to the Qoder API. */
 interface QoderMessage {
-	role: "user" | "assistant" | "tool";
+	role: "user" | "assistant" | "tool" | "system";
 	content: QoderContent | null;
 	tool_calls?: QoderToolCall[];
 	tool_call_id?: string;
@@ -150,7 +150,10 @@ function transformAssistantMessage(am: AssistantMessage): QoderMessage {
 			if (block.type === "text") {
 				content += (block as TextContent).text;
 			} else if (block.type === "thinking") {
-				content += `<thinking>${(block as ThinkingContent).thinking}</thinking>\n\n`;
+				// Skip sending previous thinking blocks for the OpenAI-compatible API.
+				// Qoder current API produces reasoning_content natively during streaming;
+				// re-emitting prior reasoning as <thinking> tags is unnecessary and
+				// can confuse newer model versions.
 			} else if (block.type === "toolCall") {
 				const tc = block as ToolCall;
 				toolCalls.push({

package/providers/routeway/routeway.ts

@@ -45,7 +45,11 @@ import { isFreeModel, registerWithGlobalToggle } from "../../lib/registry.ts";
 import { wrapSessionStartHandler } from "../../lib/session-start-metrics.ts";
 import { cleanModelName, fetchWithRetry } from "../../lib/util.ts";
 import { fetchWithTimeout } from "../../lib/util.ts";
-import { createReRegister, setupProvider } from "../../provider-helper.ts";
+import {
+	createReRegister,
+	loadCachedOrFetchModels,
+	setupProvider,
+} from "../../provider-helper.ts";
 
 const _logger = createLogger("routeway");
 
@@ -303,7 +307,9 @@ export default async function routewayProvider(pi: ExtensionAPI) {
 		return;
 	}
 
-	const allModels = await fetchRoutewayModels(apiKey);
+	const allModels = await loadCachedOrFetchModels(PROVIDER_ROUTEWAY, () =>
+		fetchRoutewayModels(apiKey),
+	);
 
 	if (allModels.length === 0) {
 		_logger.warn("[routeway] No chat models available");

package/providers/sambanova/sambanova.ts

@@ -38,7 +38,11 @@ import {
 	fetchOpenAICompatibleModels,
 	fetchWithTimeout,
 } from "../../lib/util.ts";
-import { createReRegister, setupProvider } from "../../provider-helper.ts";
+import {
+	createReRegister,
+	loadCachedOrFetchModels,
+	setupProvider,
+} from "../../provider-helper.ts";
 
 const _logger = createLogger("sambanova");
 
@@ -57,11 +61,13 @@ export default async function sambanovaProvider(pi: ExtensionAPI) {
 	}
 
 	// Fetch models via shared OpenAI-compatible helper
-	const allModels = await fetchOpenAICompatibleModels(
-		"sambanova",
-		BASE_URL_SAMBANOVA,
-		apiKey,
-		{ maxTokens: 8_192 },
+	const allModels = await loadCachedOrFetchModels(PROVIDER_SAMBANOVA, () =>
+		fetchOpenAICompatibleModels(
+			"sambanova",
+			BASE_URL_SAMBANOVA,
+			apiKey,
+			{ maxTokens: 8_192 },
+		),
 	);
 
 	if (allModels.length === 0) {

package/providers/together/together.ts

@@ -50,7 +50,11 @@ import { createProviderProbe } from "../../lib/provider-probe.ts";
 import { isFreeModel, registerWithGlobalToggle } from "../../lib/registry.ts";
 import { wrapSessionStartHandler } from "../../lib/session-start-metrics.ts";
 import { fetchWithRetry, fetchWithTimeout } from "../../lib/util.ts";
-import { createReRegister, setupProvider } from "../../provider-helper.ts";
+import {
+	createReRegister,
+	loadCachedOrFetchModels,
+	setupProvider,
+} from "../../provider-helper.ts";
 
 const _logger = createLogger("together");
 
@@ -150,7 +154,9 @@ export default async function togetherProvider(pi: ExtensionAPI) {
 	}
 
 	// Fetch models
-	const allModels = await fetchTogetherModels(apiKey);
+	const allModels = await loadCachedOrFetchModels(PROVIDER_TOGETHER, () =>
+		fetchTogetherModels(apiKey),
+	);
 
 	if (allModels.length === 0) {
 		_logger.warn("[together] No chat models available");