@agent-proxy/zcode 0.0.0-stage → 0.11.1

package/dist/individual-credentials.js

@@ -0,0 +1,39 @@
+import { decryptZcodeCredential } from "./credential-cipher.js";
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/** 读取当前账号身份对应的个人 Coding Plan Key。 */
+export function readZcodeIndividualCredential(credentials, family, env = process.env) {
+    const rawProfile = credentials[`oauth:${family}:user_info`];
+    if (rawProfile === undefined || rawProfile === null)
+        return { state: "absent" };
+    if (typeof rawProfile !== "string" || !rawProfile.trim())
+        return { state: "unavailable" };
+    let profile;
+    try {
+        profile = JSON.parse(decryptZcodeCredential(rawProfile, env));
+    }
+    catch {
+        return { state: "unavailable" };
+    }
+    // ZCode 3.14 的 user_info 使用 `user_id`；部分旧布局/接口写 `id`，
+    // 再兜底 email 只用于识别账号变化，不参与 Key 名拼接之外的任何输出。
+    const accountIdentity = isRecord(profile)
+        ? [profile.id, profile.user_id, profile.email]
+            .find((value) => typeof value === "string" && Boolean(value.trim()))
+            ?.trim() ?? ""
+        : "";
+    if (!accountIdentity)
+        return { state: "unavailable" };
+    const provider = `account:${family}-individual-coding-plan`;
+    const key = credentials[`account-provider:coding-plan:${provider}:account:${encodeURIComponent(accountIdentity)}:api-key`];
+    if (typeof key !== "string" || !key.trim())
+        return { state: "unavailable", identity: accountIdentity };
+    try {
+        const apiKey = decryptZcodeCredential(key, env).trim();
+        return apiKey ? { state: "available", identity: accountIdentity, apiKey } : { state: "unavailable", identity: accountIdentity };
+    }
+    catch {
+        return { state: "unavailable", identity: accountIdentity };
+    }
+}

package/dist/plans.d.ts

@@ -0,0 +1,19 @@
+/** ZCode billing/balance 返回的可用模型能力。 */
+export interface ZcodeBillingPlanModels {
+    planId: string;
+    name: string;
+    status: string;
+    modelIds: readonly string[];
+}
+/** ZCode 客户端用于把 billing 计划归入 Start Plan 的字符串规则。 */
+export declare function isZcodeStartPlanIdentity(planId: unknown, name: unknown): boolean;
+/**
+ * 从 billing/balance 的原始 JSON 中提取当前有效 Start Plan 实例的模型能力。
+ *
+ * 这里只消费公开的套餐元数据，不保留 balances、token 或任何凭据；未知字段和
+ * 非模型 capability 会被忽略。个人/团队 Coding Plan 不从此接口推断，调用方仍需把
+ * planId 映射到已解析的本地 Start provider。
+ */
+export declare function parseZcodeBillingPlans(value: unknown): ZcodeBillingPlanModels[];
+/** 汇总多个有效套餐的模型能力，按模型 ID 大小写不敏感去重。 */
+export declare function mergeZcodeBillingModelIds(plans: readonly ZcodeBillingPlanModels[]): string[];

package/dist/plans.js

@@ -0,0 +1,74 @@
+/** ZCode 客户端用于把 billing 计划归入 Start Plan 的字符串规则。 */
+export function isZcodeStartPlanIdentity(planId, name) {
+    const id = typeof planId === "string" ? planId.trim().toLowerCase() : "";
+    const label = typeof name === "string" ? name.trim().toLowerCase() : "";
+    // billing 端的 start-plan 实例通常由 plan_id 标识；name 仅作为兜底。
+    // 两个字段都为空时沿用客户端的默认归类，但仍由调用方单独校验 active 状态。
+    return !id && !label || id.includes("start-plan") || label.includes("start plan");
+}
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function modelIds(value) {
+    if (!Array.isArray(value))
+        return [];
+    const ids = value.flatMap((capability) => {
+        if (typeof capability !== "string" || !capability.startsWith("model:"))
+            return [];
+        const id = capability.slice("model:".length).trim();
+        return id && /^[\x20-\x7e]+$/.test(id) ? [id] : [];
+    });
+    const seen = new Set();
+    return ids.filter((id) => {
+        const key = id.toLowerCase();
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+/**
+ * 从 billing/balance 的原始 JSON 中提取当前有效 Start Plan 实例的模型能力。
+ *
+ * 这里只消费公开的套餐元数据，不保留 balances、token 或任何凭据；未知字段和
+ * 非模型 capability 会被忽略。个人/团队 Coding Plan 不从此接口推断，调用方仍需把
+ * planId 映射到已解析的本地 Start provider。
+ */
+export function parseZcodeBillingPlans(value) {
+    const root = record(value) && record(value.data) ? value.data : value;
+    const plans = record(root) && Array.isArray(root.plans) ? root.plans : [];
+    return plans.flatMap((plan) => {
+        if (!record(plan))
+            return [];
+        const status = typeof plan.status === "string" ? plan.status.trim() : "";
+        const planId = typeof plan.plan_id === "string" ? plan.plan_id.trim() : "";
+        const name = typeof plan.name === "string" ? plan.name.trim() : "";
+        if (status !== "active" || !isZcodeStartPlanIdentity(plan.plan_id, plan.name)
+            || !planId || !name || !Array.isArray(plan.entitlements))
+            return [];
+        const models = plan.entitlements.flatMap((entitlement) => record(entitlement) ? modelIds(entitlement.capabilities) : []);
+        const seen = new Set();
+        const unique = models.filter((id) => {
+            const key = id.toLowerCase();
+            if (seen.has(key))
+                return false;
+            seen.add(key);
+            return true;
+        });
+        return unique.length ? [{ planId, name, status, modelIds: unique }] : [];
+    });
+}
+/** 汇总多个有效套餐的模型能力，按模型 ID 大小写不敏感去重。 */
+export function mergeZcodeBillingModelIds(plans) {
+    const result = [];
+    const seen = new Set();
+    for (const plan of plans)
+        for (const id of plan.modelIds) {
+            const key = id.toLowerCase();
+            if (!seen.has(key)) {
+                seen.add(key);
+                result.push(id);
+            }
+        }
+    return result;
+}

package/dist/request-context.d.ts

@@ -0,0 +1,39 @@
+import type { ZcodeProviderSnapshot } from "./config.ts";
+/** ZCode 客户端内置 agent 系统提示词（真实会话流量提取），供目录条目的 base_instructions 使用。 */
+export declare const ZCODE_AGENT_SYSTEM_PROMPT: string;
+export type ZcodePlan = "coding-plan" | "start-plan" | "api-key";
+export interface ZcodeIdentity {
+    appVersion: string;
+    language: string;
+    timezone: string;
+    platform: string;
+    arch: string;
+    osVersion: string;
+}
+export interface ZcodeRequestContext {
+    requestId: string;
+    traceId: string;
+    queryId: string;
+    sessionId: string;
+    sessionType: "main" | "subagent" | "other";
+}
+export declare function readZcodeIdentity(): ZcodeIdentity;
+export declare function zcodePlan(snapshot: ZcodeProviderSnapshot): ZcodePlan;
+/** 构建完全由网关控制的来源头；不接受入站请求覆盖。 */
+export declare function buildZcodeSourceHeaders(identity: ZcodeIdentity): Headers;
+/** 模型请求所需的协议、归因和套餐鉴权头。 */
+export declare function buildZcodeModelHeaders(identity: ZcodeIdentity, context: ZcodeRequestContext, plan: ZcodePlan, apiKey: string): Headers;
+/**
+ * 只处理已转换的 Anthropic body：移除非 system 的旧标记，并在最后一个可
+ * 缓存内容块写入临时标记。thinking/redacted_thinking 永远不作为标记目标。
+ */
+export declare function decorateZcodeBody(body: Record<string, unknown>, context: ZcodeRequestContext): Record<string, unknown>;
+export declare function createZcodeContexts(options?: {
+    now?: () => number;
+    uuid?: () => string;
+    maxEntries?: number;
+    ttlMs?: number;
+}): {
+    resolve(request: Request, snapshot: ZcodeProviderSnapshot): ZcodeRequestContext;
+    close(): void;
+};

package/dist/request-context.js

@@ -0,0 +1,213 @@
+import { execFileSync } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
+import os from "node:os";
+import fingerprintData from "./fingerprint-data.json";
+const FINGERPRINT = fingerprintData;
+/** ZCode 客户端内置 agent 系统提示词（真实会话流量提取），供目录条目的 base_instructions 使用。 */
+export const ZCODE_AGENT_SYSTEM_PROMPT = FINGERPRINT.agentSystemPrompt;
+const PRINTABLE_ASCII = /^[\x20-\x7e]+$/;
+const DEFAULT_TTL_MS = 900_000;
+const DEFAULT_MAX_ENTRIES = 1024;
+function printable(value, fallback = "unknown") {
+    if (typeof value !== "string")
+        return fallback;
+    const normalized = value.trim();
+    return normalized && PRINTABLE_ASCII.test(normalized) ? normalized : fallback;
+}
+function readIdentity() {
+    let appVersion = "unknown";
+    if (process.platform === "darwin") {
+        try {
+            appVersion = printable(execFileSync("/usr/bin/plutil", ["-extract", "CFBundleShortVersionString", "raw", "/Applications/ZCode.app/Contents/Info.plist"], {
+                encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 1000,
+            }));
+        }
+        catch { /* 未安装或不可读取时保持无凭据的 unknown。 */ }
+    }
+    let language = "unknown";
+    let timezone = "unknown";
+    try {
+        language = printable(Intl.DateTimeFormat().resolvedOptions().locale);
+    }
+    catch { /* 保持 unknown。 */ }
+    try {
+        timezone = printable(Intl.DateTimeFormat().resolvedOptions().timeZone);
+    }
+    catch { /* 保持 unknown。 */ }
+    return Object.freeze({
+        appVersion,
+        language,
+        timezone,
+        platform: printable(process.platform),
+        arch: printable(os.arch()),
+        osVersion: printable(os.release()),
+    });
+}
+// 首次启用时读取公开版本；关闭 ZCode 的命令不执行额外系统查询。
+let identityCache;
+export function readZcodeIdentity() {
+    return { ...(identityCache ??= readIdentity()) };
+}
+export function zcodePlan(snapshot) {
+    if (snapshot.plan === "start-plan")
+        return "start-plan";
+    if (snapshot.plan === "api-key")
+        return "api-key";
+    return "coding-plan";
+}
+function osCategory(platform) {
+    if (platform === "darwin")
+        return "macos";
+    if (platform === "win32")
+        return "windows";
+    return platform === "unknown" ? "unknown" : "linux";
+}
+/** 构建完全由网关控制的来源头；不接受入站请求覆盖。 */
+export function buildZcodeSourceHeaders(identity) {
+    const appVersion = printable(identity.appVersion);
+    const platform = printable(identity.platform);
+    const headers = new Headers({
+        "HTTP-Referer": FINGERPRINT.referer,
+        "User-Agent": FINGERPRINT.userAgentTemplate.replace("{version}", appVersion),
+        "X-Title": FINGERPRINT.title,
+        "X-Release-Channel": FINGERPRINT.releaseChannel,
+        "X-Client-Language": printable(identity.language),
+        "X-Client-Timezone": printable(identity.timezone),
+        "X-Platform": `${platform}-${printable(identity.arch)}`,
+        "X-Os-Category": osCategory(platform),
+        "X-Os-Version": printable(identity.osVersion),
+    });
+    if (appVersion !== "unknown")
+        headers.set("X-ZCode-App-Version", appVersion);
+    headers.set("X-ZCode-Agent", FINGERPRINT.agent);
+    return headers;
+}
+/** 模型请求所需的协议、归因和套餐鉴权头。 */
+export function buildZcodeModelHeaders(identity, context, plan, apiKey) {
+    const headers = buildZcodeSourceHeaders(identity);
+    headers.set("content-type", "application/json");
+    headers.set("accept", "text/event-stream");
+    headers.set("anthropic-version", "2023-06-01");
+    headers.set("x-request-id", context.requestId);
+    headers.set("x-zcode-session-type", context.sessionType);
+    headers.set("x-zcode-trace-id", context.traceId);
+    headers.set("x-query-id", context.queryId);
+    headers.set("x-session-id", context.sessionId);
+    headers.set("authorization", `Bearer ${apiKey}`);
+    if (plan !== "start-plan")
+        headers.set("x-api-key", apiKey);
+    return headers;
+}
+function headerSessionKey(request) {
+    for (const name of ["thread-id", "session-id"]) {
+        const value = request.headers.get(name);
+        if (value) {
+            const normalized = value.trim();
+            if (normalized.length <= 128 && PRINTABLE_ASCII.test(normalized))
+                return `${name}:${normalized}`;
+        }
+    }
+}
+function clone(value) {
+    if (Array.isArray(value))
+        return value.map(clone);
+    if (value !== null && typeof value === "object")
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, clone(item)]));
+    return value;
+}
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/**
+ * 只处理已转换的 Anthropic body：移除非 system 的旧标记，并在最后一个可
+ * 缓存内容块写入临时标记。thinking/redacted_thinking 永远不作为标记目标。
+ */
+export function decorateZcodeBody(body, context) {
+    const result = clone(body);
+    const messages = result.messages;
+    if (Array.isArray(messages)) {
+        for (const message of messages) {
+            if (!record(message) || message.role === "system" || !Array.isArray(message.content))
+                continue;
+            for (const block of message.content)
+                if (record(block))
+                    delete block.cache_control;
+        }
+        outer: for (let index = messages.length - 1; index >= 0; index--) {
+            const message = messages[index];
+            if (!record(message) || message.role === "system" || !Array.isArray(message.content))
+                continue;
+            for (let blockIndex = message.content.length - 1; blockIndex >= 0; blockIndex--) {
+                const block = message.content[blockIndex];
+                if (!record(block) || block.type === "thinking" || block.type === "redacted_thinking")
+                    continue;
+                block.cache_control = { type: "ephemeral" };
+                break outer;
+            }
+        }
+    }
+    result.metadata = {
+        ...(record(result.metadata) ? result.metadata : {}),
+        user_id: JSON.stringify({ account_uuid: "", session_id: context.sessionId }),
+    };
+    return result;
+}
+export function createZcodeContexts(options = {}) {
+    const now = options.now ?? Date.now;
+    const uuid = options.uuid ?? randomUUID;
+    const maxEntries = Math.max(1, Math.trunc(options.maxEntries ?? DEFAULT_MAX_ENTRIES));
+    const ttlMs = Math.max(0, options.ttlMs ?? DEFAULT_TTL_MS);
+    const scopes = new WeakMap();
+    const sessions = new Map();
+    let closed = false;
+    function scope(snapshot) {
+        const cached = scopes.get(snapshot);
+        if (cached)
+            return cached;
+        // 摘要只作为内存 Map 的不可逆作用域，不进入返回值、请求头或日志。
+        const value = createHash("sha256").update(`${snapshot.family}\n${snapshot.providerID}\n${snapshot.apiKey}`).digest("hex");
+        scopes.set(snapshot, value);
+        return value;
+    }
+    function purge(time) {
+        for (const [key, value] of sessions)
+            if (value.expiresAt <= time)
+                sessions.delete(key);
+        while (sessions.size > maxEntries)
+            sessions.delete(sessions.keys().next().value);
+    }
+    return {
+        resolve(request, snapshot) {
+            if (closed)
+                throw new Error("ZCode 请求上下文已关闭");
+            const time = now();
+            purge(time);
+            const incoming = headerSessionKey(request);
+            let sessionId;
+            if (incoming) {
+                const key = `${scope(snapshot)}\n${incoming}`;
+                const existing = sessions.get(key);
+                if (existing && existing.expiresAt > time) {
+                    sessionId = existing.sessionId;
+                    existing.expiresAt = time + ttlMs;
+                    sessions.delete(key);
+                    sessions.set(key, existing);
+                }
+                else {
+                    sessionId = uuid();
+                    sessions.set(key, { sessionId, expiresAt: time + ttlMs });
+                    purge(time);
+                }
+            }
+            else
+                sessionId = uuid();
+            const parent = request.headers.get("x-codex-parent-thread-id")?.trim();
+            const subagent = Boolean(parent && parent.length <= 128 && PRINTABLE_ASCII.test(parent));
+            return {
+                requestId: uuid(), traceId: uuid(), queryId: uuid(), sessionId,
+                sessionType: subagent ? "subagent" : incoming ? "main" : "other",
+            };
+        },
+        close() { closed = true; sessions.clear(); },
+    };
+}

package/dist/request.d.ts

@@ -0,0 +1,5 @@
+import type { ZcodeTranslatedRequest } from "./wire.ts";
+export declare class ZcodeRequestError extends Error {
+    constructor(message: string);
+}
+export declare function translateZcodeRequest(body: Record<string, unknown>, upstreamModel: string): ZcodeTranslatedRequest;