waygate-qoder 0.0.0-stage → 0.1.1

package/dist/protocol/cosy.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Qoder CN 网关的 COSY 协议原语（v0.6.0）。
+ *
+ * 全部算法逆向自官方客户端 + 社区参考实现（EchoPing07/Qoder-2API-Go 的 auth.go），
+ * 并于 2026-10-11 对真网关实弹验证通过（model/list / user/status / chat 三发三中，
+ * 见记忆 waygate-qoder-integration 与 POC C:\tmp\qoder-poc.mjs）。
+ *
+ * 出站安全：所有头走本模块构造，绝不透传入站头（与 headers.ts 的 allowlist 纪律一致）；
+ * 凭证（dt-/drt- 令牌）只进 AES 加密的 info 块，不落日志。
+ */
+/** 客户端 CLI 版本（2026-10-11 本机实测，来源：.qoder-cn/logs/runs 下的 manifest.json）。 */
+export declare const QODER_CLI_VERSION = "1.1.61";
+/** COSY 协议版本（客户端写死值，随客户端升级漂移）。 */
+export declare const QODER_COSY_VERSION = "0.1.43";
+/** 客户端类型标识（5 = CLI 形态，实测值）。 */
+export declare const QODER_CLIENT_TYPE = "5";
+/** 与官方 CLI 同族形态的出站 UA（node 段动态取运行时，同族即可 —— 见 ua-fingerprint-plan.md）。 */
+export declare const QODER_OUT_UA: string;
+/** 登录协议版本（写死 v2）。 */
+export declare const QODER_LOGIN_VERSION = "v2";
+/** [v0.6.0] Qoder 协议的默认网关与聊天端点（chat_path 可按提供商覆写）。 */
+export declare const DEFAULT_QODER_BASE_URL = "https://gateway.qoder.com.cn";
+export declare const DEFAULT_QODER_CHAT_PATH = "/algo/api/v2/service/pro/sse/agent_chat_generation?FetchKeys=llm_model_result&AgentId=agent_common&Encode=1";
+/** 标准请求体 → 网关自定义编码（所有 Encode=1 端点的请求体格式）。 */
+export declare function qEncode(plain: string): string;
+/** 网关自定义编码 → 原文（响应侧解码用；非法字符抛错而不是静默截断）。 */
+export declare function qDecode(encoded: string): string;
+/** 提供商凭证文件（`providers/<id>.qoder.json`）里的身份材料。
+ *  来自官方客户端本地登录态（auth.v1.dat），由 tools/qoder-import-credential.mjs 导入。 */
+export interface QoderIdentity {
+    /** 访问令牌（dt-…）。过期后需从客户端重新导入（本服务不做刷新 —— 刷新会轮换
+     *  refresh token，连带把用户桌面客户端的登录态顶掉，见 translate 注释）。 */
+    token: string;
+    /** 刷新令牌（drt-…）。当前仅透传进身份块（网关校验其存在），不用于主动刷新。 */
+    refreshToken: string;
+    /** 用户 UUID（cosy-user 头与身份块都用）。 */
+    uid: string;
+    /** 显示名（身份块要求非空即可）。 */
+    name: string;
+    /** 账号档位（user/status 的 userType，如 personal_standard）。 */
+    userType: string;
+}
+/** 一次会话的加密材料。tempKey 仅本地持有；cosyKey/info 每请求头携带。 */
+export interface CosySession {
+    cosyKey: string;
+    info: string;
+}
+/** 组装 COSY 会话：tempKey=uuid[:16]（AES-128，IV=key），cosyKey=RSA(tempKey)，
+ *  info=AES-CBC(身份 JSON)。会话可复用（与签名无关），按身份缓存即可。 */
+export declare function newCosySession(identity: QoderIdentity): CosySession;
+/** 请求签名：md5(payload \n cosyKey \n date \n body \n path)。path 剥 /algo 前缀。 */
+export declare function signCosyRequest(payloadB64: string, cosyKey: string, date: string, body: string, pathWithoutAlgo: string): string;
+/** 剥掉 /algo 前缀的签名用路径（网关双形态路径共用此规则）。 */
+export declare function sigPath(urlPath: string): string;
+/** 组装完整 COSY bearer：`Bearer COSY.<payloadB64>.<sig>`。date=unix 秒（字符串）。 */
+export declare function buildCosyBearer(session: CosySession, unixDate: string, encodedBody: string, urlPath: string): string;
+export interface MachineIdentity {
+    machineId: string;
+    machineToken: string;
+    machineType: string;
+}
+/** 进程级单例：同一进程内所有请求共用一套机器身份（与官方客户端行为一致）。 */
+export declare function machineIdentity(): MachineIdentity;
+/** 组装 COSY bearer 路径的公共头（出站全部头在此构造 —— 不透传入站头）。 */
+export declare function cosyChatHeaders(session: CosySession, identity: QoderIdentity, bearer: string, unixDate: string, accept: string): Record<string, string>;

package/dist/protocol/cosy.js

@@ -0,0 +1,159 @@
+/**
+ * Qoder CN 网关的 COSY 协议原语（v0.6.0）。
+ *
+ * 全部算法逆向自官方客户端 + 社区参考实现（EchoPing07/Qoder-2API-Go 的 auth.go），
+ * 并于 2026-10-11 对真网关实弹验证通过（model/list / user/status / chat 三发三中，
+ * 见记忆 waygate-qoder-integration 与 POC C:\tmp\qoder-poc.mjs）。
+ *
+ * 出站安全：所有头走本模块构造，绝不透传入站头（与 headers.ts 的 allowlist 纪律一致）；
+ * 凭证（dt-/drt- 令牌）只进 AES 加密的 info 块，不落日志。
+ */
+import { createHash, publicEncrypt, createCipheriv, randomUUID } from 'node:crypto';
+/* ─── 指纹常量（版本字典：客户端升级漂移时只改这里，单测钉住） ─── */
+/** 客户端 CLI 版本（2026-10-11 本机实测，来源：.qoder-cn/logs/runs 下的 manifest.json）。 */
+export const QODER_CLI_VERSION = '1.1.61';
+/** COSY 协议版本（客户端写死值，随客户端升级漂移）。 */
+export const QODER_COSY_VERSION = '0.1.43';
+/** 客户端类型标识（5 = CLI 形态，实测值）。 */
+export const QODER_CLIENT_TYPE = '5';
+/** 与官方 CLI 同族形态的出站 UA（node 段动态取运行时，同族即可 —— 见 ua-fingerprint-plan.md）。 */
+export const QODER_OUT_UA = `qodercli/${QODER_CLI_VERSION} node/${process.versions.node}`;
+/** 登录协议版本（写死 v2）。 */
+export const QODER_LOGIN_VERSION = 'v2';
+/** [v0.6.0] Qoder 协议的默认网关与聊天端点（chat_path 可按提供商覆写）。 */
+export const DEFAULT_QODER_BASE_URL = 'https://gateway.qoder.com.cn';
+export const DEFAULT_QODER_CHAT_PATH = '/algo/api/v2/service/pro/sse/agent_chat_generation?FetchKeys=llm_model_result&AgentId=agent_common&Encode=1';
+/* ─── 自定义 base64（Qoder 网关变体：字母表替换 + 三段轮转 + '='→'$'） ─── */
+const CUSTOM_ALPHABET = '_doRTgHZBKcGVjlvpC,@aFSx#DPuNJme&i*MzLOEn)sUrthbf%Y^w.(kIQyXqWA!';
+const STD_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const S2C = new Map();
+const C2S = new Map();
+/* 两表等长（64 项，构造时同源生成）；i<64 时下标必然有效 —— 数组字面量的下标在
+   类型层是 string|undefined，这里用非空断言表达该不变量。 */
+for (let i = 0; i < 64; i++) {
+    S2C.set(STD_ALPHABET[i], CUSTOM_ALPHABET[i]);
+    C2S.set(CUSTOM_ALPHABET[i], STD_ALPHABET[i]);
+}
+S2C.set('=', '$');
+C2S.set('$', '=');
+/** 标准请求体 → 网关自定义编码（所有 Encode=1 端点的请求体格式）。 */
+export function qEncode(plain) {
+    const std = Buffer.from(plain, 'utf8').toString('base64');
+    const n = std.length;
+    const a = Math.floor(n / 3);
+    const rearranged = std.slice(n - a) + std.slice(a, n - a) + std.slice(0, a);
+    let out = '';
+    for (const ch of rearranged) {
+        const mapped = S2C.get(ch);
+        if (mapped === undefined)
+            throw new Error(`qEncode 遇到字母表外字符: ${JSON.stringify(ch)}`);
+        out += mapped;
+    }
+    return out;
+}
+/** 网关自定义编码 → 原文（响应侧解码用；非法字符抛错而不是静默截断）。 */
+export function qDecode(encoded) {
+    let std = '';
+    for (const ch of encoded) {
+        const mapped = C2S.get(ch);
+        if (mapped === undefined)
+            throw new Error(`qDecode 遇到字母表外字符: ${JSON.stringify(ch)}`);
+        std += mapped;
+    }
+    const n = std.length;
+    const a = Math.floor(n / 3);
+    const rearranged = std.slice(n - a) + std.slice(a, n - a) + std.slice(0, a);
+    return Buffer.from(rearranged, 'base64').toString('utf8');
+}
+/* ─── COSY 会话（身份块加密 + 请求签名） ─── */
+/** 网关服务端 RSA 公钥（客户端内写死值；加密临时 AES key 用）。 */
+const SERVER_PUBLIC_KEY = `-----BEGIN PUBLIC KEY-----
+MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDA8iMH5c02LilrsERw9t6Pv5Nc
+4k6Pz1EaDicBMpdpxKduSZu5OANqUq8er4GM95omAGIOPOh+Nx0spthYA2BqGz+l
+6HRkPJ7S236FZz73In/KVuLnwI8JJ2CbuJap8kvheCCZpmAWpb/cPx/3Vr/J6I17
+XcW+ML9FoCI6AOvOzwIDAQAB
+-----END PUBLIC KEY-----`;
+const md5hex = (s) => createHash('md5').update(s, 'utf8').digest('hex');
+/** 组装 COSY 会话：tempKey=uuid[:16]（AES-128，IV=key），cosyKey=RSA(tempKey)，
+ *  info=AES-CBC(身份 JSON)。会话可复用（与签名无关），按身份缓存即可。 */
+export function newCosySession(identity) {
+    const tempKey = Buffer.from(randomUUID().slice(0, 16), 'utf8');
+    const cosyKey = publicEncrypt({ key: SERVER_PUBLIC_KEY, padding: 1 /* RSA_PKCS1_PADDING */ }, tempKey).toString('base64');
+    /* 身份块字段序照社区实现（Go struct 序）—— 服务端解密后按 JSON 解析，
+       序不参与校验，但保持一致便于对照排查。 */
+    const plain = Buffer.from(JSON.stringify({
+        name: identity.name,
+        aid: '',
+        uid: identity.uid,
+        yx_uid: '',
+        organization_id: '',
+        organization_name: '',
+        user_type: identity.userType,
+        security_oauth_token: identity.token,
+        refresh_token: identity.refreshToken,
+    }), 'utf8');
+    const padLen = 16 - (plain.length % 16);
+    const padded = Buffer.concat([plain, Buffer.alloc(padLen, padLen)]);
+    const cipher = createCipheriv('aes-128-cbc', tempKey, tempKey.slice(0, 16));
+    cipher.setAutoPadding(false);
+    const info = Buffer.concat([cipher.update(padded), cipher.final()]).toString('base64');
+    return { cosyKey, info };
+}
+/** bearer 载荷（cosyVersion/ideVersion/info/requestId/version 五字段，base64）。
+ *  requestId 每请求新生成。 */
+function buildPayloadB64(info) {
+    return Buffer.from(JSON.stringify({
+        cosyVersion: QODER_COSY_VERSION,
+        ideVersion: '',
+        info,
+        requestId: randomUUID(),
+        version: 'v1',
+    }), 'utf8').toString('base64');
+}
+/** 请求签名：md5(payload \n cosyKey \n date \n body \n path)。path 剥 /algo 前缀。 */
+export function signCosyRequest(payloadB64, cosyKey, date, body, pathWithoutAlgo) {
+    return md5hex([payloadB64, cosyKey, date, body, pathWithoutAlgo].join('\n'));
+}
+/** 剥掉 /algo 前缀的签名用路径（网关双形态路径共用此规则）。 */
+export function sigPath(urlPath) {
+    return urlPath.startsWith('/algo') ? urlPath.slice('/algo'.length) : urlPath;
+}
+/** 组装完整 COSY bearer：`Bearer COSY.<payloadB64>.<sig>`。date=unix 秒（字符串）。 */
+export function buildCosyBearer(session, unixDate, encodedBody, urlPath) {
+    const payloadB64 = buildPayloadB64(session.info);
+    const sig = signCosyRequest(payloadB64, session.cosyKey, unixDate, encodedBody, sigPath(urlPath));
+    return `Bearer COSY.${payloadB64}.${sig}`;
+}
+let machineSingleton = null;
+/** 进程级单例：同一进程内所有请求共用一套机器身份（与官方客户端行为一致）。 */
+export function machineIdentity() {
+    if (!machineSingleton) {
+        machineSingleton = {
+            machineId: randomUUID(),
+            machineToken: (randomUUID() + randomUUID()).slice(0, 50),
+            machineType: randomUUID().slice(0, 18),
+        };
+    }
+    return machineSingleton;
+}
+/** 组装 COSY bearer 路径的公共头（出站全部头在此构造 —— 不透传入站头）。 */
+export function cosyChatHeaders(session, identity, bearer, unixDate, accept) {
+    const m = machineIdentity();
+    return {
+        'cosy-data-policy': 'AGREE',
+        'content-type': 'application/json',
+        'cosy-machinetype': m.machineType,
+        'cosy-clienttype': QODER_CLIENT_TYPE,
+        'cosy-date': unixDate,
+        'cosy-user': identity.uid,
+        'cosy-key': session.cosyKey,
+        accept,
+        authorization: bearer,
+        'accept-encoding': 'identity',
+        'cosy-version': QODER_COSY_VERSION,
+        'cosy-machineid': m.machineId,
+        'cosy-machinetoken': m.machineToken,
+        'login-version': QODER_LOGIN_VERSION,
+        'user-agent': QODER_OUT_UA,
+    };
+}

package/dist/protocol/stream-decode.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 入站解码：Qoder SSE → OpenAI SSE chunk 流（v0.6.0）。
+ *
+ * 网关帧形状（agent_chat_generation，Encode=1）：`data: {"body":"<JSON 字符串>",…}` ——
+ * 双层 JSON：wrapper.body 是**字符串化的 OpenAI 形状 chunk**（choices[].delta /
+ * usage / finish_reason），实测 2026-10-11（见记忆 waygate-qoder-integration）。
+ *
+ * usage 口径（本文件的要害）：
+ *   · 网关 usage 带 Qoder 扩展字段 `credits`（名义费率值）与 `billable`（是否实际扣费）；
+ *   · 落库铁律（反代保真）：`credit`（本服务落库的唯一权威字段）= **billable ? credits : 0**
+ *     —— 免费档 billable:false 的真实扣费就是 0；名义值不冒充实扣（与 v0.5.8 口径一致）；
+ *   · billable 字段缺失按 true（社区同判：缺失模型不静默清零积分）；
+ *   · reasoning / cached tokens 进标准 details 位 —— extractReasoningTokens /
+ *     extractCachedTokens 现有链路直接可读。
+ *
+ * 思考流：delta.reasoning_content → 原样下发（DeepSeek 惯例字段，ZCode 等客户端认识）。
+ * 流结束信号：网关直接关流（无显式 stop 帧）→ flush() 补收尾 usage chunk + [DONE]。
+ */
+/** 转换流：Qoder SSE → OpenAI SSE。网关关流时 flush 补 usage 收尾帧 + [DONE]。
+ *  `model` 由调用方注入（路由解析出的目录 id）—— 网关响应里的 model 是 'auto'
+ *  占位，不能用（见 onInnerChunk 的注释）；注入后 chunk 与落库取的模型名都正确。 */
+export declare function qoderToOpenAiSse(model?: string): TransformStream<Uint8Array, Uint8Array>;

package/dist/protocol/stream-decode.js

@@ -0,0 +1,173 @@
+/**
+ * 入站解码：Qoder SSE → OpenAI SSE chunk 流（v0.6.0）。
+ *
+ * 网关帧形状（agent_chat_generation，Encode=1）：`data: {"body":"<JSON 字符串>",…}` ——
+ * 双层 JSON：wrapper.body 是**字符串化的 OpenAI 形状 chunk**（choices[].delta /
+ * usage / finish_reason），实测 2026-10-11（见记忆 waygate-qoder-integration）。
+ *
+ * usage 口径（本文件的要害）：
+ *   · 网关 usage 带 Qoder 扩展字段 `credits`（名义费率值）与 `billable`（是否实际扣费）；
+ *   · 落库铁律（反代保真）：`credit`（本服务落库的唯一权威字段）= **billable ? credits : 0**
+ *     —— 免费档 billable:false 的真实扣费就是 0；名义值不冒充实扣（与 v0.5.8 口径一致）；
+ *   · billable 字段缺失按 true（社区同判：缺失模型不静默清零积分）；
+ *   · reasoning / cached tokens 进标准 details 位 —— extractReasoningTokens /
+ *     extractCachedTokens 现有链路直接可读。
+ *
+ * 思考流：delta.reasoning_content → 原样下发（DeepSeek 惯例字段，ZCode 等客户端认识）。
+ * 流结束信号：网关直接关流（无显式 stop 帧）→ flush() 补收尾 usage chunk + [DONE]。
+ */
+import { UpstreamError } from '../errors.js';
+function chunkJson(state, delta, finish, withUsage = false) {
+    const chunk = {
+        id: state.id,
+        object: 'chat.completion.chunk',
+        created: state.created,
+        model: state.model,
+        choices: [{ index: 0, delta, finish_reason: finish }],
+    };
+    if (withUsage && state.usage)
+        chunk.usage = state.usage;
+    return JSON.stringify(chunk);
+}
+/** 解析单个内层 chunk（OpenAI 形状），返回应下发的行（null = 无输出）。 */
+function onInnerChunk(state, inner) {
+    /* usage 两种形态都收：独立末帧（choices 空）或挂在最后一个内容帧上（GLM 式）。 */
+    const usage = inner.usage;
+    if (usage && typeof usage === 'object') {
+        const prompt = typeof usage.prompt_tokens === 'number' ? usage.prompt_tokens : 0;
+        const completion = typeof usage.completion_tokens === 'number' ? usage.completion_tokens : 0;
+        const cached = (usage.prompt_tokens_details?.cached_tokens ?? 0);
+        const reasoning = (usage.completion_tokens_details?.reasoning_tokens ?? 0);
+        /* ★ credits 口径：billable 显式为 false → 实扣 0；缺失/true → 名义 credits 值。
+           credits 缺失且 billable=true → credit 不设（extractUpstreamCredit 判 unknown）。 */
+        let credit;
+        if (usage.billable === false)
+            credit = 0;
+        else if (typeof usage.credits === 'number' && Number.isFinite(usage.credits) && usage.credits >= 0) {
+            credit = Math.round(usage.credits * 100) / 100;
+        }
+        state.usage = {
+            prompt_tokens: prompt,
+            completion_tokens: completion,
+            total_tokens: typeof usage.total_tokens === 'number' ? usage.total_tokens : prompt + completion,
+            prompt_tokens_details: { cached_tokens: cached },
+            completion_tokens_details: { reasoning_tokens: reasoning },
+            ...(credit !== undefined ? { credit } : {}),
+        };
+        state.sawContentOrUsage = true;
+    }
+    if (typeof inner.id === 'string' && inner.id && !state.id)
+        state.id = inner.id;
+    /* ⚠️ inner.model 一律**丢弃**：网关回的是 'auto'（它自己的会话标签，不是模型名）——
+       实测 2026-10-11 全链路：落库 model 被写成 'auto'，会让按模型聚合塌成一桶。
+       落库取的 model 由 ctx.modelId（路由解析出的目录 id）兜底，正是我们要的真值。 */
+    const choices = inner.choices;
+    if (!Array.isArray(choices) || choices.length === 0)
+        return null;
+    /* choices.length === 0 已在上一行挡掉；此处下标必然有效。 */
+    const choice = choices[0];
+    const delta = (choice.delta ?? {});
+    const out = {};
+    if (typeof delta.role === 'string' && delta.role)
+        out.role = delta.role;
+    if (typeof delta.content === 'string' && delta.content)
+        out.content = delta.content;
+    if (typeof delta.reasoning_content === 'string' && delta.reasoning_content)
+        out.reasoning_content = delta.reasoning_content;
+    if (Array.isArray(delta.tool_calls) && delta.tool_calls.length > 0)
+        out.tool_calls = delta.tool_calls;
+    const finish = typeof choice.finish_reason === 'string' ? choice.finish_reason : null;
+    if (finish)
+        state.finish = finish;
+    const hasOut = Object.keys(out).length > 0;
+    if (hasOut)
+        state.sawContentOrUsage = true;
+    /* usage 挂在内容帧上时（GLM 式）也要把 usage 带出去 —— 但聚合器取「最后一个非空
+       usage」，独立末帧模式由 flush() 兜底补发，这里只在有内容时附带。 */
+    return hasOut ? chunkJson(state, out, finish) : null;
+}
+/** 处理一帧（可能多行），返回应下发的行列表。 */
+function handleFrame(state, frame) {
+    const out = [];
+    for (const line of frame.split('\n')) {
+        if (!line.startsWith('data:'))
+            continue;
+        const payload = line.slice(5).trim();
+        if (!payload || payload === '[DONE]')
+            continue;
+        let wrapper;
+        try {
+            wrapper = JSON.parse(payload);
+        }
+        catch {
+            continue; // 坏帧跳过（与 openai 路径同口径）
+        }
+        /* 流内错误信封（业务码伪装成功流）：网关 10605 准入拒绝等会以
+           statusCodeValue/错误体出现在帧里 —— 抛 RelayHttpError 让主管道按失败落库。 */
+        const errBody = wrapper.error;
+        if (errBody) {
+            const msg = typeof errBody === 'string' ? errBody : String(errBody.message ?? 'unknown');
+            throw new UpstreamError(`上游（qoder）流内错误：${msg}`);
+        }
+        const bodyStr = wrapper.body;
+        if (typeof bodyStr !== 'string' || bodyStr === '')
+            continue;
+        let inner;
+        try {
+            inner = JSON.parse(bodyStr);
+        }
+        catch {
+            continue;
+        }
+        const line2 = onInnerChunk(state, inner);
+        if (line2 !== null)
+            out.push(`data: ${line2}\n\n`);
+    }
+    return out;
+}
+/** 转换流：Qoder SSE → OpenAI SSE。网关关流时 flush 补 usage 收尾帧 + [DONE]。
+ *  `model` 由调用方注入（路由解析出的目录 id）—— 网关响应里的 model 是 'auto'
+ *  占位，不能用（见 onInnerChunk 的注释）；注入后 chunk 与落库取的模型名都正确。 */
+export function qoderToOpenAiSse(model = '') {
+    const state = {
+        id: '',
+        model,
+        created: Math.floor(Date.now() / 1000),
+        finish: null,
+        sawContentOrUsage: false,
+        usage: null,
+    };
+    const encoder = new TextEncoder();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    const handle = (frame, emit) => {
+        for (const line of handleFrame(state, frame))
+            emit(line);
+    };
+    return new TransformStream({
+        transform(chunk, controller) {
+            const emit = (s) => controller.enqueue(encoder.encode(s));
+            buffer += decoder.decode(chunk, { stream: true });
+            let sep;
+            while ((sep = buffer.indexOf('\n\n')) >= 0) {
+                const frame = buffer.slice(0, sep);
+                buffer = buffer.slice(sep + 2);
+                handle(frame, emit);
+            }
+        },
+        flush(controller) {
+            const emit = (s) => controller.enqueue(encoder.encode(s));
+            const tail = buffer + decoder.decode();
+            if (tail.trim() !== '')
+                handle(tail, emit);
+            /* 网关关流 = 结束信号（无显式 stop 帧）：补收尾帧（带 usage）+ [DONE]。
+               ⚠️ 一帧内容/usage 都没见过就关流 = 上游异常 —— 不补帧不补 DONE，
+               readUpstreamSse 按既有断流语义判失败（绝不伪造成功空流）。 */
+            if (!state.sawContentOrUsage)
+                return;
+            const fin = chunkJson(state, {}, state.finish ?? 'stop', true);
+            emit(`data: ${fin}\n\n`);
+            emit('data: [DONE]\n\n');
+        },
+    });
+}

package/dist/protocol/translate.d.ts

@@ -0,0 +1,87 @@
+/**
+ * 出站翻译：OpenAI Chat Completions → Qoder agent_chat_generation（v0.6.0）。
+ *
+ * 与 anthropic-upstream/translate.ts（OpenAI→Anthropic）同族：入口收本服务统一的
+ * ChatRequestBody（已过 prompt 改写），出口是 Qoder 网关的请求体（JSON 字符串 ——
+ * 外层再由 cosy.ts 的 qEncode 编码）。
+ *
+ * 消息折叠策略（v1 口径，与 Anthropic 路线一致）：
+ *   · system 消息 → 顶部 system 块？Qoder 无独立 system 字段 —— 并入首条 user 文本
+ *     （网关侧 chat_context 才是「本轮输入」的主通道，messages 是会话历史）；
+ *   · role:"tool" 的工具结果 → 序列化并进紧随的 user 消息文本（Anthropic 路线同款）；
+ *   · assistant 的 tool_calls 历史 → 序列化为其文本的一部分（v1 不回灌原生
+ *     tool_calls 块 —— 客户端通常重发完整历史，序列化保语义）；
+ *   · 未识别字段静默忽略（与两个入站方向口径一致）。
+ *
+ * 参数透传（verbatim 政策，与社区实现一致）：temperature/top_p/stop 等 **原样**进
+ * parameters；网关是裁判。max_tokens 缺省补 8192（官方客户端自己的回落）。
+ * reasoning_effort 若客户端给了（o 系参数），映射 model_config.is_reasoning。
+ */
+import type { ChatMessage, ChatRequestBody } from 'waygate-core';
+/** Qoder 消息（v1：纯文本形态 + 空白 response_meta）。 */
+interface QoderMessage {
+    role: 'user' | 'assistant';
+    content: string;
+    response_meta: {
+        id: string;
+        usage: Record<string, number | object>;
+    };
+    reasoning_content_signature: string;
+    contents: Array<{
+        type: 'text';
+        text: string;
+    }>;
+}
+/** 折叠 OpenAI 消息序列为 Qoder user/assistant 交替历史 + 提取本轮 prompt。 */
+export declare function buildQoderMessages(messages: ChatMessage[]): {
+    history: QoderMessage[];
+    prompt: string;
+};
+/** Qoder 请求体（ChatRequestBody 镜像，字段序照社区实现 —— 序列化形状稳定）。 */
+export interface QoderRequestBody {
+    request_id: string;
+    request_set_id: string;
+    chat_record_id: string;
+    stream: boolean;
+    chat_task: string;
+    chat_context: {
+        extra: {
+            modelConfig: {
+                is_reasoning: boolean;
+                key: string;
+            };
+            originalContent: {
+                type: string;
+                text: string;
+            };
+        };
+        text: {
+            type: string;
+            text: string;
+        };
+    };
+    session_id: string;
+    source: number;
+    version: string;
+    aliyun_user_type: string;
+    session_type: string;
+    agent_id: string;
+    task_id: string;
+    model_config: {
+        key: string;
+        is_vl: boolean;
+        is_reasoning: boolean;
+        source: string;
+    };
+    messages: QoderMessage[];
+    business: {
+        id: string;
+        name: string;
+        begin_at: number;
+    };
+    parameters: Record<string, unknown>;
+    tools?: unknown;
+}
+/** 组装 Qoder 请求体。qoderModelKey = 目录 id（即网关内部 key，如 qfmodel）。 */
+export declare function toQoderRequest(body: ChatRequestBody, qoderModelKey: string, userType: string): QoderRequestBody;
+export {};

package/dist/protocol/translate.js

@@ -0,0 +1,140 @@
+/**
+ * 出站翻译：OpenAI Chat Completions → Qoder agent_chat_generation（v0.6.0）。
+ *
+ * 与 anthropic-upstream/translate.ts（OpenAI→Anthropic）同族：入口收本服务统一的
+ * ChatRequestBody（已过 prompt 改写），出口是 Qoder 网关的请求体（JSON 字符串 ——
+ * 外层再由 cosy.ts 的 qEncode 编码）。
+ *
+ * 消息折叠策略（v1 口径，与 Anthropic 路线一致）：
+ *   · system 消息 → 顶部 system 块？Qoder 无独立 system 字段 —— 并入首条 user 文本
+ *     （网关侧 chat_context 才是「本轮输入」的主通道，messages 是会话历史）；
+ *   · role:"tool" 的工具结果 → 序列化并进紧随的 user 消息文本（Anthropic 路线同款）；
+ *   · assistant 的 tool_calls 历史 → 序列化为其文本的一部分（v1 不回灌原生
+ *     tool_calls 块 —— 客户端通常重发完整历史，序列化保语义）；
+ *   · 未识别字段静默忽略（与两个入站方向口径一致）。
+ *
+ * 参数透传（verbatim 政策，与社区实现一致）：temperature/top_p/stop 等 **原样**进
+ * parameters；网关是裁判。max_tokens 缺省补 8192（官方客户端自己的回落）。
+ * reasoning_effort 若客户端给了（o 系参数），映射 model_config.is_reasoning。
+ */
+import { randomUUID } from 'node:crypto';
+const BLANK_USAGE = {
+    prompt_tokens: 0,
+    completion_tokens: 0,
+    total_tokens: 0,
+    completion_tokens_details: { reasoning_tokens: 0 },
+    prompt_tokens_details: { cached_tokens: 0 },
+};
+function qMsg(role, text) {
+    return {
+        role,
+        content: '',
+        response_meta: { id: '', usage: { ...BLANK_USAGE, completion_tokens_details: { ...BLANK_USAGE.completion_tokens_details }, prompt_tokens_details: { ...BLANK_USAGE.prompt_tokens_details } } },
+        reasoning_content_signature: '',
+        contents: [{ type: 'text', text }],
+    };
+}
+/** 工具调用历史序列化（人类可读、保 id/name/arguments 全量）。 */
+function serializeToolCalls(calls) {
+    if (!Array.isArray(calls))
+        return '';
+    return calls
+        .map((c) => {
+        const fn = c.function ?? {};
+        return `[tool_call id=${c.id ?? ''} name=${fn.name ?? ''}] ${fn.arguments ?? ''}`;
+    })
+        .join('\n');
+}
+/** 折叠 OpenAI 消息序列为 Qoder user/assistant 交替历史 + 提取本轮 prompt。 */
+export function buildQoderMessages(messages) {
+    const folded = [];
+    /** 待并入下一条 user 的碎片（system 前缀 / tool 结果 / assistant 工具调用说明）。 */
+    let pendingUserPrefix = [];
+    let latestUserPrompt = '';
+    for (const m of messages) {
+        const text = typeof m.content === 'string' ? m.content : m.content == null ? '' : JSON.stringify(m.content);
+        if (m.role === 'system') {
+            pendingUserPrefix.push(`[system] ${text}`);
+            continue;
+        }
+        if (m.role === 'tool') {
+            pendingUserPrefix.push(`[tool_result ${String(m.tool_call_id ?? '')}] ${text}`);
+            continue;
+        }
+        if (m.role === 'assistant') {
+            const tc = serializeToolCalls(m.tool_calls);
+            const full = tc ? `${text}\n${tc}` : text;
+            if (full.trim())
+                folded.push(qMsg('assistant', full));
+            continue;
+        }
+        /* user（未知角色按 user 处理 —— 与网关宽容口径一致） */
+        const merged = [...pendingUserPrefix, text].filter((s) => s !== '').join('\n\n');
+        pendingUserPrefix = [];
+        latestUserPrompt = merged;
+        folded.push(qMsg('user', merged));
+    }
+    /* 残余 system/tool 碎片（序列以非 user 结尾的病态情况）：并入最后一条 user。 */
+    if (pendingUserPrefix.length > 0 && folded.length > 0) {
+        const last = folded[folded.length - 1];
+        if (last && last.role === 'user') {
+            last.contents = [{ type: 'text', text: `${last.contents[0]?.text ?? ''}\n\n${pendingUserPrefix.join('\n\n')}` }];
+            latestUserPrompt = last.contents[0]?.text ?? '';
+        }
+        else {
+            folded.push(qMsg('user', pendingUserPrefix.join('\n\n')));
+            latestUserPrompt = pendingUserPrefix.join('\n\n');
+        }
+        pendingUserPrefix = [];
+    }
+    if (!latestUserPrompt && folded.length > 0) {
+        const last = folded[folded.length - 1];
+        if (last && last.role === 'user')
+            latestUserPrompt = last.contents[0]?.text ?? '';
+    }
+    return { history: folded, prompt: latestUserPrompt };
+}
+/** parameters 透传白名单（其余字段不进 parameters —— verbatim 政策内只搬已知键，
+ *  防止把 stream_options 之类的 OpenAI 控制字段误投给网关）。 */
+const PARAM_PASSTHROUGH = ['temperature', 'top_p', 'stop', 'frequency_penalty', 'presence_penalty', 'seed', 'response_format', 'tool_choice', 'reasoning_effort', 'max_thinking_tokens'];
+/** 组装 Qoder 请求体。qoderModelKey = 目录 id（即网关内部 key，如 qfmodel）。 */
+export function toQoderRequest(body, qoderModelKey, userType) {
+    const { history, prompt } = buildQoderMessages(body.messages);
+    const nid = randomUUID();
+    const isReasoning = body.reasoning_effort != null && body.reasoning_effort !== 'none';
+    const parameters = {};
+    for (const k of PARAM_PASSTHROUGH) {
+        if (body[k] !== undefined)
+            parameters[k] = body[k];
+    }
+    if (body.max_tokens !== undefined)
+        parameters.max_tokens = body.max_tokens;
+    else if (parameters.max_tokens === undefined)
+        parameters.max_tokens = 8192; // 官方客户端自己的回落
+    return {
+        request_id: nid,
+        request_set_id: randomUUID(),
+        chat_record_id: nid,
+        stream: true, // 恒开流（管道流式原生，与 anthropic 路线同口径）
+        chat_task: 'FREE_INPUT',
+        chat_context: {
+            extra: {
+                modelConfig: { is_reasoning: isReasoning, key: qoderModelKey },
+                originalContent: { type: 'text', text: prompt },
+            },
+            text: { type: 'text', text: prompt },
+        },
+        session_id: randomUUID(),
+        source: 1,
+        version: '3',
+        aliyun_user_type: userType,
+        session_type: 'qodercli',
+        agent_id: 'agent_common',
+        task_id: 'common',
+        model_config: { key: qoderModelKey, is_vl: true, is_reasoning: isReasoning, source: 'system' },
+        messages: history,
+        business: { id: randomUUID(), name: prompt.slice(0, 30) || 'chat', begin_at: Date.now() },
+        parameters,
+        tools: Array.isArray(body.tools) ? body.tools : undefined,
+    };
+}