waygate-mmcode 0.0.0-stage → 0.2.0

package/dist/credential.d.ts

@@ -0,0 +1,49 @@
+/**
+ * MiniMax Code 凭证：读本机客户端登录态 + access token 生命周期。
+ *
+ * ## 客户端登录态（明文 JSON，比 Qoder 简单）
+ *   %USERPROFILE%/.minimax/auth/prod/cn/mcode-public/auth.json
+ *   { schemaVersion, records: { "<clientKey>": { accessToken, refreshToken, expiresAtMs, … } } }
+ *   —— `records` 只有一个条目（当前登录账号）。**明文**，无需解密。
+ *
+ * ## ⚠️ 凭证互斥（本工具最大的坑，比 Qoder 严重）
+ * MiniMax 的 refresh token 是**一次性**的：刷新成功后旧 token 立刻作废。
+ * 且**同一账号同时只有一个有效会话** —— 本工具与官方客户端同时用一个账号会**互相踢下线**。
+ * ⇒ 强烈建议给本工具配**专用账号**（与日常客户端分开）。
+ *
+ * ## token 生命周期
+ *   · access token（`mmoat_`）寿命短（约 1–4 小时），过期前 2 分钟自动刷新；
+ *   · refresh token（`mmort_`）刷新后会被上游**轮换**，必须写回本地（否则下次刷新失败）。
+ */
+/** 客户端登录态文件（可用 MINIMAX_AUTH_FILE 覆盖）。 */
+export declare function clientAuthFile(): string;
+/** 本工具自己的凭证落盘位置（`~/.waygate/mmcode/credential.json`）。 */
+export declare function credentialPath(): string;
+export interface MinimaxCredential {
+    accessToken: string;
+    refreshToken: string;
+    /** access token 过期时刻（epoch ms）。 */
+    expiresAt: number;
+    /** 账号标识（客户端文件里的 uid/uin，若有；仅用于展示）。 */
+    account?: string;
+}
+/** 从客户端 auth.json 读出第一条记录（当前登录账号）。 */
+export declare function readClientCredential(): MinimaxCredential;
+/** 读本工具已落盘的凭证（无则 null）。 */
+export declare function readSavedCredential(): MinimaxCredential | null;
+/** 落盘（0600）。refresh token 轮换后也要调用本函数写回。 */
+export declare function saveCredential(cred: MinimaxCredential): string;
+/**
+ * token 管理器：缓存 access token，过期前自动刷新（并发去重），轮换时写回。
+ *
+ * 与 relay 里那个 Nest 服务同语义，但去掉了框架依赖 —— 核心就是「到期就换、换完写回」。
+ */
+export declare class MinimaxTokenManager {
+    private readonly onLog;
+    private cached;
+    private inFlight;
+    constructor(onLog?: (line: string) => void);
+    /** 取可用 access token（必要时刷新并写回）。 */
+    accessToken(): Promise<string>;
+    private refresh;
+}

package/dist/credential.js

@@ -0,0 +1,175 @@
+/**
+ * MiniMax Code 凭证：读本机客户端登录态 + access token 生命周期。
+ *
+ * ## 客户端登录态（明文 JSON，比 Qoder 简单）
+ *   %USERPROFILE%/.minimax/auth/prod/cn/mcode-public/auth.json
+ *   { schemaVersion, records: { "<clientKey>": { accessToken, refreshToken, expiresAtMs, … } } }
+ *   —— `records` 只有一个条目（当前登录账号）。**明文**，无需解密。
+ *
+ * ## ⚠️ 凭证互斥（本工具最大的坑，比 Qoder 严重）
+ * MiniMax 的 refresh token 是**一次性**的：刷新成功后旧 token 立刻作废。
+ * 且**同一账号同时只有一个有效会话** —— 本工具与官方客户端同时用一个账号会**互相踢下线**。
+ * ⇒ 强烈建议给本工具配**专用账号**（与日常客户端分开）。
+ *
+ * ## token 生命周期
+ *   · access token（`mmoat_`）寿命短（约 1–4 小时），过期前 2 分钟自动刷新；
+ *   · refresh token（`mmort_`）刷新后会被上游**轮换**，必须写回本地（否则下次刷新失败）。
+ */
+import { chmodSync, existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { commandDir } from 'waygate-core';
+import { CredentialError, UpstreamError } from './errors.js';
+const MINIMAX_TOKEN_ENDPOINT = 'https://account.minimax.cn/oauth2/token';
+/** 提前刷新余量：过期前 120s 内的 token 视为不可用（时钟偏差 + 请求耗时）。 */
+const REFRESH_MARGIN_MS = 120_000;
+/** MiniMax Code 客户端公开的 OAuth 客户端参数（与桌面端同源）。 */
+const OAUTH_FORM = {
+    client_id: 'mcode-public',
+    scope: 'agent.default',
+    audience: 'agent-backend',
+};
+/** 客户端登录态文件（可用 MINIMAX_AUTH_FILE 覆盖）。 */
+export function clientAuthFile() {
+    const override = (process.env.MINIMAX_AUTH_FILE ?? '').trim();
+    if (override)
+        return override;
+    const home = process.env.USERPROFILE ?? homedir();
+    return join(home, '.minimax', 'auth', 'prod', 'cn', 'mcode-public', 'auth.json');
+}
+/** 本工具自己的凭证落盘位置（`~/.waygate/mmcode/credential.json`）。 */
+export function credentialPath() {
+    return join(commandDir('mmcode'), 'credential.json');
+}
+/** 从客户端 auth.json 读出第一条记录（当前登录账号）。 */
+export function readClientCredential() {
+    const file = clientAuthFile();
+    if (!existsSync(file)) {
+        throw new CredentialError(`找不到客户端登录态 ${file} —— 请先在 MiniMax Code 客户端登录；或用 MINIMAX_AUTH_FILE 指定文件`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(file, 'utf8'));
+    }
+    catch (err) {
+        throw new CredentialError(`客户端登录态不是合法 JSON：${err.message}`);
+    }
+    const records = parsed.records ?? {};
+    const keys = Object.keys(records);
+    if (keys.length === 0) {
+        throw new CredentialError('客户端当前未登录（auth.json 无记录）—— 请在客户端登录后重试');
+    }
+    const rec = records[keys[0]];
+    const accessToken = typeof rec.accessToken === 'string' ? rec.accessToken : '';
+    const refreshToken = typeof rec.refreshToken === 'string' ? rec.refreshToken : '';
+    if (!accessToken || !refreshToken) {
+        throw new CredentialError('登录态缺少 accessToken 或 refreshToken —— 客户端未登录？请在客户端登录后重试');
+    }
+    return {
+        accessToken,
+        refreshToken,
+        expiresAt: typeof rec.expiresAtMs === 'number' ? rec.expiresAtMs : 0,
+        account: typeof rec.loginEpoch === 'string' ? rec.loginEpoch.slice(0, 8) : undefined,
+    };
+}
+/** 读本工具已落盘的凭证（无则 null）。 */
+export function readSavedCredential() {
+    const file = credentialPath();
+    if (!existsSync(file))
+        return null;
+    try {
+        const c = JSON.parse(readFileSync(file, 'utf8'));
+        return c.accessToken && c.refreshToken ? c : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** 落盘（0600）。refresh token 轮换后也要调用本函数写回。 */
+export function saveCredential(cred) {
+    const path = credentialPath();
+    writeFileSync(path, JSON.stringify(cred, null, 2) + '\n', { mode: 0o600 });
+    try {
+        chmodSync(path, 0o600);
+    }
+    catch {
+        /* Windows 语义有限 */
+    }
+    return path;
+}
+/**
+ * token 管理器：缓存 access token，过期前自动刷新（并发去重），轮换时写回。
+ *
+ * 与 relay 里那个 Nest 服务同语义，但去掉了框架依赖 —— 核心就是「到期就换、换完写回」。
+ */
+export class MinimaxTokenManager {
+    onLog;
+    cached = null;
+    inFlight = null;
+    constructor(onLog = () => { }) {
+        this.onLog = onLog;
+    }
+    /** 取可用 access token（必要时刷新并写回）。 */
+    async accessToken() {
+        const cred = this.cached ?? readSavedCredential() ?? readClientCredential();
+        this.cached = cred;
+        if (Date.now() + REFRESH_MARGIN_MS < cred.expiresAt)
+            return cred.accessToken;
+        if (this.inFlight)
+            return this.inFlight;
+        const job = this.refresh(cred).finally(() => {
+            this.inFlight = null;
+        });
+        this.inFlight = job;
+        return job;
+    }
+    async refresh(cred) {
+        if (!cred.refreshToken.startsWith('mmort_')) {
+            throw new CredentialError('凭证不是有效的 MiniMax refresh token（应以 mmort_ 开头）—— 请用 mmcode login 重新导入');
+        }
+        const form = new URLSearchParams({
+            grant_type: 'refresh_token',
+            refresh_token: cred.refreshToken,
+            ...OAUTH_FORM,
+        });
+        let res;
+        try {
+            res = await fetch(MINIMAX_TOKEN_ENDPOINT, {
+                method: 'POST',
+                headers: { 'content-type': 'application/x-www-form-urlencoded' },
+                body: form.toString(),
+                signal: AbortSignal.timeout(20_000),
+            });
+        }
+        catch (err) {
+            throw new UpstreamError(`刷新令牌失败（account.minimax.cn 不可达）：${err.message}`);
+        }
+        if (!res.ok) {
+            const raw = await res.text().catch(() => '');
+            throw new CredentialError(`刷新令牌被拒（HTTP ${res.status}）：${raw.slice(0, 200) || '无响应体'}。` +
+                `refresh token 可能已失效或已被官方客户端占用 —— 在客户端重新登录后跑 mmcode login。`);
+        }
+        const grant = (await res.json().catch(() => null));
+        if (!grant || typeof grant.access_token !== 'string') {
+            throw new CredentialError('令牌刷新响应缺少 access_token');
+        }
+        const expiresAt = typeof grant.expires_at_ms === 'number' && grant.expires_at_ms > Date.now()
+            ? grant.expires_at_ms
+            : typeof grant.expires_in === 'number' && grant.expires_in > 0
+                ? Date.now() + (grant.expires_in > 100_000 ? grant.expires_in : grant.expires_in * 1000)
+                : Date.now() + 3_600_000;
+        const next = {
+            ...cred,
+            accessToken: grant.access_token,
+            expiresAt,
+        };
+        /* refresh token 轮换（一次性）—— 必须写回，否则下次刷新用的是已作废的旧值。 */
+        if (typeof grant.refresh_token === 'string' && grant.refresh_token.startsWith('mmort_')) {
+            next.refreshToken = grant.refresh_token;
+        }
+        this.cached = next;
+        saveCredential(next);
+        this.onLog(`令牌已刷新（有效至 ${new Date(expiresAt).toISOString()}）`);
+        return next.accessToken;
+    }
+}

package/dist/errors.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 上游错误（core 会兜成 502 + OpenAI 形状错误体给客户端）。
+ */
+export declare class UpstreamError extends Error {
+    readonly name = "UpstreamError";
+    constructor(message: string);
+}
+/** 凭证类错误（启动/doctor 用：提示用户跑 login，而不是抛栈）。 */
+export declare class CredentialError extends Error {
+    readonly name = "CredentialError";
+    constructor(message: string);
+}

package/dist/errors.js

@@ -0,0 +1,16 @@
+/**
+ * 上游错误（core 会兜成 502 + OpenAI 形状错误体给客户端）。
+ */
+export class UpstreamError extends Error {
+    name = 'UpstreamError';
+    constructor(message) {
+        super(message);
+    }
+}
+/** 凭证类错误（启动/doctor 用：提示用户跑 login，而不是抛栈）。 */
+export class CredentialError extends Error {
+    name = 'CredentialError';
+    constructor(message) {
+        super(message);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+/**
+ * waygate-mmcode —— MiniMax Code 本地反代（命令 `mmcode`）。
+ *
+ * 读取本机 MiniMax Code 客户端的登录态，在本机提供 Anthropic/OpenAI 兼容的聊天端点。
+ *
+ * ⚠️ 凭证互斥：MiniMax 同一账号只能有一个有效会话 —— 本工具与官方客户端同账号会互相踢下线。
+ * 建议给本工具配专用账号。详见 README。
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+/**
+ * waygate-mmcode —— MiniMax Code 本地反代（命令 `mmcode`）。
+ *
+ * 读取本机 MiniMax Code 客户端的登录态，在本机提供 Anthropic/OpenAI 兼容的聊天端点。
+ *
+ * ⚠️ 凭证互斥：MiniMax 同一账号只能有一个有效会话 —— 本工具与官方客户端同账号会互相踢下线。
+ * 建议给本工具配专用账号。详见 README。
+ */
+import { runCli } from 'waygate-core';
+import { createMmcodeAdapter } from './adapter.js';
+const VERSION = '0.2.0';
+const code = await runCli(createMmcodeAdapter(), { version: VERSION });
+process.exit(code);

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

@@ -0,0 +1,37 @@
+/**
+ * Anthropic SSE → OpenAI SSE 字节流转换器（v0.5.0，出站 anthropic 协议的响应方向）。
+ *
+ * 形态是 **TransformStream**：吃 mavis 上游的 Anthropic 事件流，吐 OpenAI 形状的
+ * `data: {chat.completion.chunk}` 行。这样 `readUpstreamSse`（首字超时/空闲看门狗/
+ * 聚合/落库/断流判定）**一行不改**地复用 —— mavis 上游在管道里"看起来"就是 OpenAI
+ * 兼容上游。与入站编码器 `../anthropic/stream-events.ts` 互为镜像。
+ *
+ * 事件映射：
+ *   message_start                          → 首 chunk（delta.role；记录 id/model/input usage）
+ *   content_block_start{tool_use}          → chunk delta.tool_calls[{index,id,type,name}]
+ *   content_block_delta{text_delta}        → chunk delta.content
+ *   content_block_delta{thinking_delta}    → chunk delta.reasoning_content
+ *   content_block_delta{input_json_delta}  → chunk delta.tool_calls[].function.arguments
+ *   message_delta                          → 记录 stop_reason / usage（output 权威累计值）
+ *   message_stop                           → 收尾 chunk（finish_reason + usage 全量）+ [DONE]
+ *   error                                  → 抛错（流错误 → readUpstreamSse 的失败路径）
+ *
+ * usage 口径（与 usage-tokens.ts 的权威字段对齐）：
+ *   prompt_tokens = input_tokens + cache_creation_input_tokens + cache_read_input_tokens
+ *   completion_tokens = output_tokens
+ *   prompt_tokens_details.cached_tokens = cache_read_input_tokens
+ *
+ *   ⚠️ [v0.5.10 纠偏] Anthropic 的 `input_tokens` **不含**缓存部分（生产实测：
+ *   input=43 而 cache_read=128 —— 43 个 token 的 prompt 读不出 128 个缓存 token）。
+ *   此前头注写"input_tokens 是全量，含缓存命中"是错的，照它实现导致
+ *   prompt_tokens 被低估、且 cached_tokens > prompt_tokens（缓存命中率 297%）。
+ *   三个输入字段相加才是真输入；cached_tokens 只取**读**命中（cache_creation 是写，不算命中）。
+ *   ⚠️ 不读顶层 cached_tokens —— 与 usage-tokens.ts 同理由：顶层字段有历史坑。
+ *
+ * 未收到 message_stop 就断流 → 不补 [DONE] → readUpstreamSse 按断流失败处理（语义正确）。
+ */
+/**
+ * 转换流。收到 `message_stop` 后在收尾 chunk 之后补 `data: [DONE]`；
+ * 上游提前断流则不补 —— readUpstreamSse 按断流失败处理。
+ */
+export declare function anthropicToOpenAiSse(): TransformStream<Uint8Array, Uint8Array>;

package/dist/protocol/stream-decode.js

@@ -0,0 +1,207 @@
+/**
+ * Anthropic SSE → OpenAI SSE 字节流转换器（v0.5.0，出站 anthropic 协议的响应方向）。
+ *
+ * 形态是 **TransformStream**：吃 mavis 上游的 Anthropic 事件流，吐 OpenAI 形状的
+ * `data: {chat.completion.chunk}` 行。这样 `readUpstreamSse`（首字超时/空闲看门狗/
+ * 聚合/落库/断流判定）**一行不改**地复用 —— mavis 上游在管道里"看起来"就是 OpenAI
+ * 兼容上游。与入站编码器 `../anthropic/stream-events.ts` 互为镜像。
+ *
+ * 事件映射：
+ *   message_start                          → 首 chunk（delta.role；记录 id/model/input usage）
+ *   content_block_start{tool_use}          → chunk delta.tool_calls[{index,id,type,name}]
+ *   content_block_delta{text_delta}        → chunk delta.content
+ *   content_block_delta{thinking_delta}    → chunk delta.reasoning_content
+ *   content_block_delta{input_json_delta}  → chunk delta.tool_calls[].function.arguments
+ *   message_delta                          → 记录 stop_reason / usage（output 权威累计值）
+ *   message_stop                           → 收尾 chunk（finish_reason + usage 全量）+ [DONE]
+ *   error                                  → 抛错（流错误 → readUpstreamSse 的失败路径）
+ *
+ * usage 口径（与 usage-tokens.ts 的权威字段对齐）：
+ *   prompt_tokens = input_tokens + cache_creation_input_tokens + cache_read_input_tokens
+ *   completion_tokens = output_tokens
+ *   prompt_tokens_details.cached_tokens = cache_read_input_tokens
+ *
+ *   ⚠️ [v0.5.10 纠偏] Anthropic 的 `input_tokens` **不含**缓存部分（生产实测：
+ *   input=43 而 cache_read=128 —— 43 个 token 的 prompt 读不出 128 个缓存 token）。
+ *   此前头注写"input_tokens 是全量，含缓存命中"是错的，照它实现导致
+ *   prompt_tokens 被低估、且 cached_tokens > prompt_tokens（缓存命中率 297%）。
+ *   三个输入字段相加才是真输入；cached_tokens 只取**读**命中（cache_creation 是写，不算命中）。
+ *   ⚠️ 不读顶层 cached_tokens —— 与 usage-tokens.ts 同理由：顶层字段有历史坑。
+ *
+ * 未收到 message_stop 就断流 → 不补 [DONE] → readUpstreamSse 按断流失败处理（语义正确）。
+ */
+import { UpstreamError } from '../errors.js';
+/** Anthropic stop_reason → OpenAI finish_reason（与入站 mapStopReason 互逆）。 */
+function mapFinish(stop) {
+    switch (stop) {
+        case 'end_turn':
+        case 'stop_sequence':
+            return 'stop';
+        case 'max_tokens':
+            return 'length';
+        case 'tool_use':
+            return 'tool_calls';
+        case 'refusal':
+            return 'content_filter';
+        default:
+            return stop ? 'stop' : null;
+    }
+}
+/** 真输入 = 非缓存输入 + 缓存写入 + 缓存读取（三者都过 prompt，见头注纠偏）。 */
+function totalInput(state) {
+    return state.inputTokens + state.cacheCreation + state.cacheRead;
+}
+function chunkJson(state, delta, finish = null, 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) {
+        const prompt = totalInput(state);
+        chunk.usage = {
+            prompt_tokens: prompt,
+            completion_tokens: state.outputTokens,
+            total_tokens: prompt + state.outputTokens,
+            prompt_tokens_details: { cached_tokens: state.cacheRead },
+        };
+    }
+    return JSON.stringify(chunk);
+}
+/** 处理单个 Anthropic 事件 JSON，返回应下发的 OpenAI chunk 行（null = 无输出）。 */
+function onData(state, ev) {
+    switch (ev.type) {
+        case 'message_start': {
+            const msg = (ev.message ?? {});
+            state.id = typeof msg.id === 'string' ? msg.id : `msg_${state.created}`;
+            state.model = typeof msg.model === 'string' ? msg.model : '';
+            const usage = (msg.usage ?? {});
+            state.inputTokens = typeof usage.input_tokens === 'number' ? usage.input_tokens : 0;
+            state.outputTokens = typeof usage.output_tokens === 'number' ? usage.output_tokens : 0;
+            state.cacheRead = typeof usage.cache_read_input_tokens === 'number' ? usage.cache_read_input_tokens : 0;
+            state.cacheCreation = typeof usage.cache_creation_input_tokens === 'number' ? usage.cache_creation_input_tokens : 0;
+            return chunkJson(state, { role: 'assistant', content: '' });
+        }
+        case 'content_block_start': {
+            const index = typeof ev.index === 'number' ? ev.index : 0;
+            const block = (ev.content_block ?? {});
+            if (block.type === 'tool_use') {
+                const toolIndex = state.nextToolIndex++;
+                state.toolIndexByBlock.set(index, toolIndex);
+                return chunkJson(state, {
+                    tool_calls: [{
+                            index: toolIndex,
+                            id: typeof block.id === 'string' ? block.id : '',
+                            type: 'function',
+                            function: { name: typeof block.name === 'string' ? block.name : '', arguments: '' },
+                        }],
+                });
+            }
+            return null; // text/thinking 块首帧无内容，delta 里会带
+        }
+        case 'content_block_delta': {
+            const index = typeof ev.index === 'number' ? ev.index : 0;
+            const delta = (ev.delta ?? {});
+            if (delta.type === 'text_delta' && typeof delta.text === 'string' && delta.text !== '') {
+                return chunkJson(state, { content: delta.text });
+            }
+            if (delta.type === 'thinking_delta' && typeof delta.thinking === 'string' && delta.thinking !== '') {
+                return chunkJson(state, { reasoning_content: delta.thinking });
+            }
+            if (delta.type === 'input_json_delta' && typeof delta.partial_json === 'string' && delta.partial_json !== '') {
+                const toolIndex = state.toolIndexByBlock.get(index) ?? 0;
+                return chunkJson(state, { tool_calls: [{ index: toolIndex, function: { arguments: delta.partial_json } }] });
+            }
+            return null;
+        }
+        case 'message_delta': {
+            const delta = (ev.delta ?? {});
+            if (typeof delta.stop_reason === 'string')
+                state.finish = mapFinish(delta.stop_reason);
+            const usage = (ev.usage ?? {});
+            if (typeof usage.output_tokens === 'number')
+                state.outputTokens = usage.output_tokens;
+            if (typeof usage.input_tokens === 'number')
+                state.inputTokens = usage.input_tokens;
+            if (typeof usage.cache_read_input_tokens === 'number')
+                state.cacheRead = usage.cache_read_input_tokens;
+            if (typeof usage.cache_creation_input_tokens === 'number')
+                state.cacheCreation = usage.cache_creation_input_tokens;
+            return null;
+        }
+        case 'message_stop':
+            return chunkJson(state, {}, state.finish ?? 'stop', true);
+        case 'error': {
+            const err = (ev.error ?? {});
+            throw new UpstreamError(`上游（anthropic 协议）流内错误：${String(err.message ?? 'unknown')}`);
+        }
+        default:
+            return null; // ping / content_block_stop / 未知事件：忽略
+    }
+}
+/**
+ * 转换流。收到 `message_stop` 后在收尾 chunk 之后补 `data: [DONE]`；
+ * 上游提前断流则不补 —— readUpstreamSse 按断流失败处理。
+ */
+export function anthropicToOpenAiSse() {
+    const state = {
+        id: '',
+        model: '',
+        created: Math.floor(Date.now() / 1000),
+        finish: null,
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheRead: 0,
+        cacheCreation: 0,
+        toolIndexByBlock: new Map(),
+        nextToolIndex: 0,
+    };
+    const encoder = new TextEncoder();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let sawStop = false;
+    const handleFrame = (frame, enqueue) => {
+        for (const line of frame.split('\n')) {
+            if (!line.startsWith('data:'))
+                continue;
+            const payload = line.slice(5).trim();
+            if (!payload || payload === '[DONE]')
+                continue;
+            let ev;
+            try {
+                ev = JSON.parse(payload);
+            }
+            catch {
+                continue; // 坏帧跳过（与 openai 路径同口径）
+            }
+            const chunk = onData(state, ev);
+            if (chunk !== null)
+                enqueue(`data: ${chunk}\n\n`);
+            if (ev.type === 'message_stop') {
+                sawStop = true;
+                enqueue('data: [DONE]\n\n');
+            }
+        }
+    };
+    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);
+                handleFrame(frame, emit);
+            }
+        },
+        flush(controller) {
+            /* 尾部残帧（无空行结尾的最后一帧）也处理；未见到 message_stop 不补 DONE。 */
+            const tail = buffer + decoder.decode();
+            if (tail.trim() !== '')
+                handleFrame(tail, controller ? (s) => controller.enqueue(encoder.encode(s)) : () => undefined);
+            void sawStop;
+        },
+    });
+}

package/dist/protocol/translate.d.ts

@@ -0,0 +1,42 @@
+/**
+ * 出站翻译：OpenAI Chat Completions → Anthropic Messages（v0.5.0）。
+ *
+ * 服务于 anthropic 协议的上游（MiniMax Code 的 mavis 网关）。与入站翻译
+ * `../anthropic/translate-request.ts`（Anthropic→OpenAI）互为镜像：字段映射
+ * 从那边逐条对照反推，两边的语义必须保持一致。
+ *
+ * 设计取舍：
+ *   · **流式恒开**：与 openai 路径同口径（本服务的管道是流式原生的）；
+ *   · max_tokens 必填（Anthropic 契约）：缺省回落 8192；
+ *   · tool 消息折叠：OpenAI 的 `role:"tool"` 序列必须并成紧跟其后的 user 消息里的
+ *     tool_result 块（Anthropic 契约）；
+ *   · 连续同角色消息合并（Anthropic 要求 user/assistant 交替，OpenAI 不要求）；
+ *   · 未识别字段静默忽略 —— 与两个入站方向的口径一致。
+ */
+import type { ChatRequestBody } from 'waygate-core';
+/** Anthropic Messages 请求体（出站最小集）。 */
+export interface AnthropicOutRequest {
+    model: string;
+    max_tokens: number;
+    stream: true;
+    messages: Array<{
+        role: 'user' | 'assistant';
+        content: unknown;
+    }>;
+    system?: string;
+    temperature?: number;
+    top_p?: number;
+    tools?: Array<{
+        name: string;
+        description: string;
+        input_schema: unknown;
+    }>;
+    tool_choice?: {
+        type: 'auto' | 'any' | 'none';
+    } | {
+        type: 'tool';
+        name: string;
+    };
+}
+/** 翻译入口。输入是本服务内部的 ChatRequestBody（已过 rewrite 层）。 */
+export declare function toAnthropicRequest(body: ChatRequestBody): AnthropicOutRequest;