Skip to content

Formerly KrillinAI, VideoTranslation and Dubbing Tool for 120+ Languages. Open-source AI workspace for creators, powered by Codex. Video downloader, video translation, create videos, images, audios, and edits with Agents in one place. For your Social Media like YouTube, TikTok, Instagram, etc.

feat: decouple official model requests from the account gateway

wulien-centerd1d35dcbf793
diff --git a/apps/daemon/src/api/server.ts b/apps/daemon/src/api/server.ts
index f94e4855..13dcebb5 100644
--- a/apps/daemon/src/api/server.ts
+++ b/apps/daemon/src/api/server.ts
@@ -567,7 +567,8 @@ export async function buildServer(input: BuildServerInput) {
officialBindings = createGatewayRuntimeBindings({
codexHome: home, baseUrl: bootstrap.baseUrl, model: model.id, direct: bootstrap.transport === 'openrouter-direct',
readProxy: readCommonProxy,
- beginUse: async () => { const use = await gatewayAccount.beginModelUse(); return { key: use.credentials.modelKey, release: use.release }; },
+ beginUse: async () => { const use = await gatewayAccount.beginModelUse(); return { key: use.credentials.modelKey, keyVersion: use.credentials.keyVersion, release: use.release }; },
+ recoverKey: async keyVersion => { const updated = await gatewayAccount.recoverModelCredentials(keyVersion); return { key: updated.modelKey, keyVersion: updated.keyVersion }; },
readCredentials: async () => ({ accountId: bootstrap.account.id, modelKey: bootstrap.modelKey, keyVersion: bootstrap.keyVersion }),
closeRuntime: async () => { await Promise.all([...officialManagers.values()].map(manager => manager.close())); }
});
diff --git a/apps/daemon/src/gateway/account-service.ts b/apps/daemon/src/gateway/account-service.ts
index fdb7769e..4b438b44 100644
--- a/apps/daemon/src/gateway/account-service.ts
+++ b/apps/daemon/src/gateway/account-service.ts
@@ -1,7 +1,7 @@
import type { GatewayAccountState, GatewayBalanceSnapshot, GatewayBalanceState, ServiceSource } from '@opencreator/protocol';
import { z } from 'zod';
import { createGatewayConfigStore, type GatewayCredentials } from './config-store.js';
-import { accountSchema, bootstrapSchema, catalogSchema, probeCredentialsSchema, GatewayError, type GatewayBootstrap, type GatewayClient, type GatewayDeviceGrant, type GatewayProbeCredentials } from './client.js';
+import { accountSchema, bootstrapSchema, cachedModelUsePolicy, catalogSchema, probeCredentialsSchema, GatewayError, type GatewayBootstrap, type GatewayClient, type GatewayDeviceGrant, type GatewayProbeCredentials } from './client.js';
import { officialModelPolicy, withModelCatalog, type OfficialModelAccess } from './model-access.js';
export function createGatewayAccountService(input: {
@@ -45,17 +45,46 @@ export function createGatewayAccountService(input: {
let closing = false;
let usageMutation = Promise.resolve();
let usageTimer: NodeJS.Timeout | undefined;
+ let bindingSyncWork: Promise<void> | undefined;
+ let maintenanceWork: Promise<void> | undefined;
+ let maintenanceFailures = 0;
+ let runtimeCloseWork: Promise<void> | undefined;
const saveConfiguration = () => store.writeConfiguration({ source: state.source, bindingVersion: state.bindingVersion, selectedModels });
function serialize<T>(work: () => Promise<T>): Promise<T> { const result = mutation.then(work); mutation = result.then(() => undefined, () => undefined); return result; }
function fail(error: unknown) { state.activationState = 'blocked'; state.activationError = { code: error instanceof GatewayError ? error.code : 'services_not_ready', message: '官方服务尚未就绪,请重试' }; }
function assertIdle() { if (localUses > 0 || input.hasActiveTasks()) throw new GatewayError('active_tasks', 409); }
function assertSignedIn() { if (!credentials || state.authState !== 'signed_in') throw new GatewayError('auth_required', 401); return credentials; }
+ function usesCachedModelKey() { return credentials?.modelUsePolicy === cachedModelUsePolicy && credentials.transport === 'openrouter-direct' && credentials.keyRotation === false; }
+ function restoreModelAccessError(code: NonNullable<GatewayCredentials['modelAccessError']>) {
+ if (code === 'auth_required') state = { ...state, authState: 'expired', activationState: 'inactive', bindingVersion: null, activationError: null };
+ else fail(new GatewayError(code, 403));
+ }
+ async function blockConfirmedModelAccess(error: unknown, expected: number, accountId: string | undefined) {
+ if (!(error instanceof GatewayError) || !usesCachedModelKey() || closing || accessPaused || generation !== expected
+ || state.authState !== 'signed_in' || credentials?.account?.id !== accountId) return false;
+ const code = error.status === 401 ? 'auth_required' : error.status === 403 && ['account_disabled', 'payment_review_required'].includes(error.code) ? error.code as NonNullable<GatewayCredentials['modelAccessError']> : undefined;
+ if (!code) return false;
+ generation++;
+ credentials = { ...credentials!, modelAccessError: code };
+ restoreModelAccessError(code);
+ runtimeTextModel = undefined; accessController?.abort();
+ clearInterval(usageTimer); usageTimer = undefined;
+ // An async image worker may itself be waiting for this recovery to return.
+ runtimeCloseWork ??= input.closeRuntime().catch(() => undefined).finally(() => { runtimeCloseWork = undefined; });
+ await store.writeCredentials(credentials);
+ return true;
+ }
+ async function withAccountAccess<T>(work: () => Promise<T>): Promise<T> {
+ const expected = generation; const accountId = credentials?.account?.id;
+ try { return await work(); }
+ catch (error) { await blockConfirmedModelAccess(error, expected, accountId); throw error; }
+ }
async function visibleBootstrap(bootstrap: GatewayBootstrap) {
const eligible = withModelCatalog(bootstrap, officialModelPolicy(bootstrap.models));
return input.modelAccess && eligible.transport === 'openrouter-direct' ? input.modelAccess.prepare(eligible) : eligible;
}
function needsAccessibleRuntime() {
- return input.modelAccess && credentials?.transport === 'openrouter-direct' && state.authState === 'signed_in'
+ return credentials?.transport === 'openrouter-direct' && !credentials.modelAccessError && state.authState === 'signed_in'
&& state.source === 'gateway' && !closing && !accessPaused && (state.activationState === 'ready' || accessBlocked)
&& (!credentials.defaults?.text || accessBlocked || runtimeTextModel !== credentials.defaults.text);
}
@@ -72,7 +101,7 @@ export function createGatewayAccountService(input: {
} catch (error) { accessBlocked = true; runtimeTextModel = undefined; fail(error); await input.closeRuntime(); }
}
function scheduleModelAccess() {
- if (!input.modelAccess || closing || accessPaused || accessWork || credentials?.transport !== 'openrouter-direct' || state.authState !== 'signed_in'
+ if (!input.modelAccess || closing || accessPaused || accessWork || credentials?.modelAccessError || credentials?.transport !== 'openrouter-direct' || state.authState !== 'signed_in'
|| (state.activationState !== 'ready' && !accessBlocked) || Date.now() - accessUpdatedAt < 30_000) return;
accessUpdatedAt = Date.now();
const controller = new AbortController(); accessController = controller;
@@ -107,13 +136,14 @@ export function createGatewayAccountService(input: {
await saveConfiguration();
if (!credentials) return;
state.account = credentials.account ?? null; state.authState = 'signed_in'; state.models = credentials.models ?? [];
+ if (credentials.modelAccessError) { restoreModelAccessError(credentials.modelAccessError); return; }
if (input.deferStartupActivation) {
const cached = bootstrapSchema.safeParse(credentials);
if (cached.success) state.models = (await visibleBootstrap(cached.data)).models;
state.activationState = 'loading';
return;
}
- await refresh();
+ if (!usesCachedModelKey()) await refresh();
await activateCurrent();
} catch (error) { fail(error); }
}
@@ -137,11 +167,13 @@ export function createGatewayAccountService(input: {
if (Date.parse(original.accessExpiresAt) > Date.now() + 60_000) return;
try {
const tokens = await input.client.refresh(original.refreshToken);
- if (closing || accessPaused || generation !== expected || credentials !== original || state.authState !== 'signed_in') return;
- credentials = { ...original, ...tokens, accessExpiresAt: new Date(Date.now() + tokens.expiresIn * 1000).toISOString() };
+ if (closing || accessPaused || generation !== expected || credentials?.refreshToken !== original.refreshToken || state.authState !== 'signed_in') return;
+ // 同一登录会话内只更新令牌,保留并发同步的模型凭据。
+ credentials = { ...assertSignedIn(), ...tokens, accessExpiresAt: new Date(Date.now() + tokens.expiresIn * 1000).toISOString() };
await store.writeCredentials(credentials);
} catch (error) {
- if (!closing && !accessPaused && error instanceof GatewayError && error.status === 401 && generation === expected && credentials === original && state.authState === 'signed_in') {
+ if (await blockConfirmedModelAccess(error, expected, original.account?.id)) throw error;
+ if (!closing && !accessPaused && error instanceof GatewayError && error.status === 401 && generation === expected && credentials?.refreshToken === original.refreshToken && state.authState === 'signed_in') {
state = { ...state, authState: 'expired', activationState: 'inactive', bindingVersion: null, activationError: null };
runtimeTextModel = undefined; accessController?.abort();
clearInterval(usageTimer); usageTimer = undefined;
@@ -153,9 +185,11 @@ export function createGatewayAccountService(input: {
try { await refreshWork; } finally { refreshWork = undefined; }
}
async function activateCurrent() {
+ await runtimeCloseWork;
// Connecting a new session must not wait for unrelated or persisted jobs.
if (state.activationState === 'ready') assertIdle();
- await refresh();
+ const cached = usesCachedModelKey() && !credentials?.modelAccessError ? bootstrapSchema.safeParse(credentials) : undefined;
+ if (!cached?.success) await refresh();
if (closing || accessPaused) return;
const original = assertSignedIn(); const expected = generation;
state.activationState = 'loading'; state.activationError = null;
@@ -164,7 +198,7 @@ export function createGatewayAccountService(input: {
await saveConfiguration();
await reportUsage();
if (closing || accessPaused || generation !== expected || state.authState !== 'signed_in') return;
- const bootstrap = await input.client.bootstrap(original.accessToken, { rotate: !input.hasPendingTasks?.() });
+ const bootstrap = cached?.success ? cached.data : await input.client.bootstrap(original.accessToken, { rotate: !input.hasPendingTasks?.(), modelUsePolicy: cachedModelUsePolicy });
if (closing || accessPaused || generation !== expected || state.authState !== 'signed_in') return;
if (original.account && bootstrap.account.id !== original.account.id) throw new GatewayError('account_mismatch');
state.account = bootstrap.account;
@@ -174,7 +208,7 @@ export function createGatewayAccountService(input: {
const visible = await visibleBootstrap(bootstrap);
if (closing || accessPaused || generation !== expected || state.authState !== 'signed_in') return;
selectedModels = { ...visible.defaults }; state.selectedModels = { ...selectedModels };
- credentials = { ...original, ...bootstrap, defaults: visible.defaults };
+ credentials = { ...original, ...bootstrap, defaults: visible.defaults, modelAccessError: undefined };
await store.writeCredentials(credentials);
if (closing || accessPaused || generation !== expected || state.authState !== 'signed_in') return;
state.account = bootstrap.account; state.models = visible.models;
@@ -190,7 +224,12 @@ export function createGatewayAccountService(input: {
state = { ...state, source: 'gateway', activationState: 'ready', account: bootstrap.account, models: visible.models, bindingVersion: bootstrap.bindingVersion, activationError: null };
await reportUsage();
startUsageHeartbeat();
- } catch (error) { runtimeTextModel = undefined; if (!closing && !accessPaused) fail(error); await input.closeRuntime(); }
+ } catch (error) {
+ runtimeTextModel = undefined;
+ if (await blockConfirmedModelAccess(error, expected, original.account?.id)) return;
+ if (!closing && !accessPaused) fail(error);
+ await input.closeRuntime();
+ }
scheduleModelAccess();
}
async function readProfile() {
@@ -202,12 +241,13 @@ export function createGatewayAccountService(input: {
await refresh();
if (closing || accessPaused) return;
const original = assertSignedIn(); const expected = generation;
- const profile = z.object({ account: accountSchema }).parse(await input.client.request('/api/v1/me', original.accessToken));
+ const profile = z.object({ account: accountSchema }).parse(await withAccountAccess(() => input.client.request('/api/v1/me', original.accessToken)));
await serialize(async () => {
if (closing || accessPaused || expected !== generation || credentials !== original || state.authState !== 'signed_in') return;
if (original.account && profile.account.id !== original.account.id) throw new GatewayError('account_mismatch');
const next = { ...original, account: profile.account };
await store.writeCredentials(next);
+ if (closing || accessPaused || expected !== generation || credentials !== original || state.authState !== 'signed_in') return;
credentials = next; state.account = profile.account;
});
})().catch(() => undefined);
@@ -223,10 +263,13 @@ export function createGatewayAccountService(input: {
await refresh();
if (closing || accessPaused) return;
const original = assertSignedIn(); const expected = generation;
- const catalog = catalogSchema.parse(await input.client.request('/api/v1/client/models', original.accessToken));
+ const catalog = catalogSchema.parse(await withAccountAccess(() => input.client.request('/api/v1/client/models', original.accessToken)));
await serialize(async () => {
if (closing || accessPaused || generation !== expected || credentials !== original || state.source !== 'gateway' || state.authState !== 'signed_in' || input.hasActiveTasks() || input.hasPendingTasks?.()) return;
- if (original.rotationPending || JSON.stringify(catalog.models) !== JSON.stringify(original.models)) await activateCurrent();
+ if (original.rotationPending || JSON.stringify(catalog.models) !== JSON.stringify(original.models)) {
+ if (usesCachedModelKey()) { await synchronizeBinding(); await synchronizeAccessibleRuntime(); }
+ else await activateCurrent();
+ }
});
})().catch(() => undefined);
try { await catalogWork; } finally { catalogWork = undefined; }
@@ -319,8 +362,14 @@ export function createGatewayAccountService(input: {
}
}
async function readModelCredentials(): Promise<{ accountId: string; modelKey: string; keyVersion: string; bindingVersion: string; baseUrl: string; transport?: GatewayBootstrap['transport']; models: GatewayBootstrap['models']; defaults: Record<string, string> }> {
- await initialize(); await refresh();
+ await initialize();
+ if (!usesCachedModelKey()) await refresh();
+ return currentModelCredentials();
+ }
+ function currentModelCredentials() {
+ if (closing || accessPaused) throw new GatewayError('auth_required', 401);
const value = assertSignedIn();
+ if (value.modelAccessError) throw new GatewayError(value.modelAccessError, value.modelAccessError === 'auth_required' ? 401 : 403);
if (state.source !== 'gateway' || state.activationState !== 'ready' || !value.account || !value.modelKey || !value.keyVersion || !value.bindingVersion || !value.baseUrl || !value.models || !value.defaults) throw new GatewayError('services_not_ready');
return { accountId: value.account.id, modelKey: value.modelKey, keyVersion: value.keyVersion, bindingVersion: value.bindingVersion, baseUrl: value.baseUrl, transport: value.transport, models: structuredClone(state.models), defaults: { ...value.defaults } };
}
@@ -331,7 +380,7 @@ export function createGatewayAccountService(input: {
if (platformProbeCredentials && Date.parse(platformProbeCredentials.expiresAt) > Date.now() + 60_000) return platformProbeCredentials;
if (platformProbeWork) return platformProbeWork;
const work = (async () => {
- const value = probeCredentialsSchema.parse(await input.client.request('/api/v1/client/probe-credentials', current.accessToken, {}));
+ const value = probeCredentialsSchema.parse(await withAccountAccess(() => input.client.request('/api/v1/client/probe-credentials', current.accessToken, {})));
if (generation !== expected || state.authState !== 'signed_in' || credentials?.account?.id !== current.account?.id) throw new GatewayError('auth_required', 401);
if (value.modelKey === credentials?.modelKey || Date.parse(value.expiresAt) <= Date.now()) throw new GatewayError('services_not_ready');
platformProbeCredentials = value;
@@ -342,7 +391,7 @@ export function createGatewayAccountService(input: {
}
function reportUsage(allowClosing = false) {
const result = usageMutation.then(async () => {
- if ((closing && !allowClosing) || !credentials?.keyRotation || !credentials.keyVersion || state.authState !== 'signed_in') return undefined;
+ if ((closing && !allowClosing) || usesCachedModelKey() || !credentials?.keyRotation || !credentials.keyVersion || state.authState !== 'signed_in') return undefined;
await refresh();
if (closing && !allowClosing) return undefined;
const current = assertSignedIn(); const expected = generation;
@@ -358,34 +407,65 @@ export function createGatewayAccountService(input: {
return result;
}
function startUsageHeartbeat() {
- if (closing || accessPaused || usageTimer || !credentials?.keyRotation || input.automaticPolling === false) return;
+ if (closing || accessPaused || usageTimer || input.automaticPolling === false) return;
+ if (usesCachedModelKey()) { scheduleMaintenance(60_000); return; }
+ if (!credentials?.keyRotation) return;
usageTimer = setInterval(() => { void reportUsage().catch(() => undefined); }, 10_000);
usageTimer.unref();
}
- async function synchronizeBinding() {
+ function scheduleMaintenance(milliseconds: number) {
+ if (closing || accessPaused || state.authState !== 'signed_in' || state.activationState !== 'ready' || !usesCachedModelKey() || input.automaticPolling === false) return;
+ usageTimer = setTimeout(() => {
+ usageTimer = undefined;
+ maintenanceWork = (async () => { await refresh(); await synchronizeBinding(); await serialize(synchronizeAccessibleRuntime); maintenanceFailures = 0; })()
+ .catch(() => { maintenanceFailures++; })
+ .finally(() => {
+ maintenanceWork = undefined;
+ const delay = Math.min(300_000, 60_000 * 2 ** Math.min(maintenanceFailures, 3));
+ scheduleMaintenance(Math.round(delay * (0.9 + Math.random() * 0.2)));
+ });
+ }, milliseconds);
+ usageTimer.unref();
+ }
+ function synchronizeBinding(): Promise<void> {
+ bindingSyncWork ??= performBindingSync().finally(() => { bindingSyncWork = undefined; });
+ return bindingSyncWork;
+ }
+ async function performBindingSync() {
const current = assertSignedIn(); const expected = generation;
- const bootstrap = await input.client.bootstrap(current.accessToken, { rotate: false });
- if (generation !== expected || state.authState !== 'signed_in') throw new GatewayError('auth_required', 401);
+ let bootstrap: GatewayBootstrap;
+ try { bootstrap = await input.client.bootstrap(current.accessToken, { rotate: false }); }
+ catch (error) { await blockConfirmedModelAccess(error, expected, current.account?.id); throw error; }
+ if (closing || accessPaused || generation !== expected || state.authState !== 'signed_in') throw new GatewayError('auth_required', 401);
if (bootstrap.account.id !== current.account?.id) throw new GatewayError('account_mismatch');
for (const [modality, model] of Object.entries(selectedModels)) {
if (bootstrap.models.some(candidate => candidate.modality === modality && candidate.id === model)) bootstrap.defaults[modality] = model;
}
const visible = await visibleBootstrap(bootstrap);
- credentials = { ...assertSignedIn(), ...bootstrap, defaults: visible.defaults };
+ if (closing || accessPaused || generation !== expected || state.authState !== 'signed_in') throw new GatewayError('auth_required', 401);
+ const deferCatalog = usesCachedModelKey() && (localUses > 0 || input.hasActiveTasks() || input.hasPendingTasks?.());
+ const latest = assertSignedIn();
+ credentials = { ...latest, ...bootstrap, defaults: deferCatalog ? latest.defaults : visible.defaults, models: deferCatalog ? latest.models : bootstrap.models };
await store.writeCredentials(credentials);
- state.bindingVersion = bootstrap.bindingVersion; state.models = visible.models;
- selectedModels = { ...visible.defaults }; state.selectedModels = { ...selectedModels };
+ if (closing || accessPaused || generation !== expected || state.authState !== 'signed_in') throw new GatewayError('auth_required', 401);
+ state.bindingVersion = bootstrap.bindingVersion;
+ if (!deferCatalog) {
+ state.models = visible.models; catalogUpdatedAt = Date.now();
+ selectedModels = { ...visible.defaults }; state.selectedModels = { ...selectedModels };
+ }
await saveConfiguration();
}
async function acquireModelUse() {
- await readModelCredentials();
+ const snapshot = await readModelCredentials();
+ const cached = usesCachedModelKey();
localUses++;
let released = false;
const release = async () => {
if (released) return;
released = true; localUses--;
- await reportUsage().catch(() => undefined);
+ if (!cached) await reportUsage().catch(() => undefined);
};
+ if (cached) return { credentials: snapshot, release };
try {
let version: string | undefined;
try { version = await reportUsage(); }
@@ -399,6 +479,14 @@ export function createGatewayAccountService(input: {
} catch (error) { await release(); throw error; }
}
const beginModelUse = () => acquireModelUse();
+ async function recoverModelCredentials(keyVersion: string) {
+ await initialize();
+ if (!usesCachedModelKey()) throw new GatewayError('model_auth_required', 401);
+ if (currentModelCredentials().keyVersion !== keyVersion) return currentModelCredentials();
+ await refresh();
+ await synchronizeBinding();
+ return currentModelCredentials();
+ }
async function logout() {
await initialize();
accessPaused = true;
@@ -410,6 +498,7 @@ export function createGatewayAccountService(input: {
clearInterval(usageTimer); usageTimer = undefined;
await cancelAuthorization();
await refreshWork?.catch(() => undefined);
+ await runtimeCloseWork;
await input.closeRuntime();
runtimeTextModel = undefined;
if (credentials) await input.client.logout(credentials.accessToken).catch(() => undefined);
@@ -418,7 +507,7 @@ export function createGatewayAccountService(input: {
state = { ...state, authState: 'signed_out', activationState: 'inactive', account: null, models: [], bindingVersion: null, activationError: null };
}).finally(() => { accessPaused = false; });
}
- async function billing(path: string, body?: unknown) { await initialize(); await refresh(); return input.client.request(path, assertSignedIn().accessToken, body); }
+ async function billing(path: string, body?: unknown) { await initialize(); await refresh(); const current = assertSignedIn(); return withAccountAccess(() => input.client.request(path, current.accessToken, body)); }
async function readBalance(): Promise<GatewayBalanceState> {
try {
const value = z.object({ balance: z.object({ availableUnits: z.string().regex(/^\d+$/), reservedUnits: z.string().regex(/^\d+$/), periodEnd: z.string().nullable(), asOf: z.string() }) }).parse(await billing('/api/v1/billing/summary'));
@@ -428,13 +517,13 @@ export function createGatewayAccountService(input: {
return {
initialize, startBackgroundRestore,
peekState() { return structuredClone(state); },
- startAuthorization, cancelAuthorization, pollAuthorization, checkAuthorization, refresh, logout, modelCredentials, beginModelUse, probeCredentials, readBalance, billing,
+ startAuthorization, cancelAuthorization, pollAuthorization, checkAuthorization, refresh, logout, modelCredentials, beginModelUse, recoverModelCredentials, probeCredentials, readBalance, billing,
readPlans() { return input.client.request('/api/v1/plans', ''); },
async readAvatar(accountId: string) {
await initialize(); await refresh();
const current = assertSignedIn(); const expected = generation;
if (!current.account?.avatarUrl || current.account.id !== accountId) throw new GatewayError('avatar_unavailable', 404);
- const image = await input.client.avatar(current.accessToken, accountId);
+ const image = await withAccountAccess(() => input.client.avatar(current.accessToken, accountId));
if (expected !== generation || state.authState !== 'signed_in' || credentials?.account?.id !== accountId) throw new GatewayError('avatar_unavailable', 404);
return image;
},
@@ -457,13 +546,19 @@ export function createGatewayAccountService(input: {
},
async selectModel(modality: import('@opencreator/protocol').GatewayModel['modality'], model: string) {
await initialize(); await serialize(async () => {
- assertIdle(); const current = assertSignedIn();
+ assertIdle(); const current = assertSignedIn(); const expected = generation;
if (state.source !== 'gateway' || state.activationState !== 'ready' || !current.defaults || !state.models.some(candidate => candidate.modality === modality && candidate.id === model && (modality !== 'text' || candidate.capabilities.includes('responses')))) throw new GatewayError('invalid_model', 400);
if (input.hasPendingTasks?.()) throw new GatewayError('active_tasks', 409);
const next = { ...current, defaults: { ...current.defaults, [modality]: model } };
if (modality === 'text') { await input.activateRuntime(bootstrapSchema.parse(next)); runtimeTextModel = model; }
- credentials = next; selectedModels = { ...next.defaults }; state.selectedModels = { ...selectedModels };
- await store.writeCredentials(next); await saveConfiguration();
+ if (closing || accessPaused || generation !== expected || state.authState !== 'signed_in' || credentials?.modelAccessError) {
+ runtimeTextModel = undefined; await input.closeRuntime(); throw new GatewayError('auth_required', 401);
+ }
+ // Runtime 激活期间可能更新凭据,只合并本次模型选择。
+ const latest = assertSignedIn();
+ credentials = { ...latest, defaults: { ...latest.defaults, [modality]: model } };
+ selectedModels = { ...credentials.defaults }; state.selectedModels = { ...selectedModels };
+ await store.writeCredentials(credentials); await saveConfiguration();
});
return structuredClone(state);
},
@@ -472,7 +567,9 @@ export function createGatewayAccountService(input: {
closing = true; input.client.cancelPendingRequests?.(); accessController?.abort();
clearTimeout(pollTimer); clearInterval(usageTimer); usageTimer = undefined;
await initialization; await startupRestoreWork; await stateRefreshWork?.catch(() => undefined);
+ await maintenanceWork; await bindingSyncWork?.catch(() => undefined);
await accessWork; await profileWork; await catalogWork; await mutation; await refreshWork?.catch(() => undefined);
+ await runtimeCloseWork;
await input.closeRuntime();
if (!restoring && state.activationState === 'ready') await reportUsage(true).catch(() => undefined);
await usageMutation; generation++;
diff --git a/apps/daemon/src/gateway/client.ts b/apps/daemon/src/gateway/client.ts
index ce0e49e4..dcfd7196 100644
--- a/apps/daemon/src/gateway/client.ts
+++ b/apps/daemon/src/gateway/client.ts
@@ -18,13 +18,16 @@ const modelSchema = z.object({
});
export const catalogSchema = z.object({ models: z.array(modelSchema).min(1) });
export const accountSchema = z.object({ id: z.string().min(1), email: z.string(), verified: z.boolean(), avatarUrl: z.string().url().max(2048).optional() });
-export const bootstrapSchema = z.object({
+export const cachedModelUsePolicy = 'cached-key-v1';
+export const bootstrapCredentialsSchema = z.object({
schemaVersion: z.literal(1), account: accountSchema,
transport: z.enum(['gateway', 'openrouter-direct']).optional(),
keyRotation: z.boolean().optional(), rotationPending: z.boolean().optional(),
+ modelUsePolicy: z.literal(cachedModelUsePolicy).optional(),
modelKey: z.string().min(1), keyVersion: z.string().min(1), bindingVersion: z.string().min(1), baseUrl: z.string().url(),
models: z.array(modelSchema), defaults: z.record(z.string())
});
+export const bootstrapSchema = bootstrapCredentialsSchema.refine(value => value.modelUsePolicy !== cachedModelUsePolicy || (value.transport === 'openrouter-direct' && value.keyRotation === false), 'Cached model credentials require a stable direct binding');
export type GatewayBootstrap = z.infer<typeof bootstrapSchema>;
export const probeCredentialsSchema = z.object({
costBearer: z.literal('platform'), modelKey: z.string().min(1), keyVersion: z.string().min(1),
@@ -39,7 +42,7 @@ export type GatewayClient = {
pollDevice(id: string, secret: string): Promise<GatewayTokens>;
cancelDevice(id: string, secret: string): Promise<void>;
refresh(refresh: string): Promise<GatewayTokens>;
- bootstrap(access: string, options?: { rotate: boolean }): Promise<GatewayBootstrap>;
+ bootstrap(access: string, options?: { rotate: boolean; modelUsePolicy?: typeof cachedModelUsePolicy }): Promise<GatewayBootstrap>;
avatar(access: string, accountId: string): Promise<{ data: Uint8Array; contentType: string }>;
logout(access: string): Promise<void>;
request(path: string, access: string, body?: unknown): Promise<unknown>;
@@ -102,7 +105,10 @@ export function createGatewayClient(origin: string, fetcher: typeof fetch = fetc
async cancelDevice(attemptId, deviceSecret) { await request('/api/v1/auth/device/cancel', '', { attemptId, deviceSecret }); },
async refresh(refreshToken) { return tokenSchema.parse(await request('/api/v1/auth/refresh', '', { refreshToken })); },
async bootstrap(access, options) {
- const value = bootstrapSchema.parse(await request('/api/v1/client/bootstrap' + (options ? `?rotate=${options.rotate ? '1' : '0'}` : ''), access));
+ const query = new URLSearchParams();
+ if (options) query.set('rotate', options.rotate ? '1' : '0');
+ if (options?.modelUsePolicy) query.set('modelUsePolicy', options.modelUsePolicy);
+ const value = bootstrapSchema.parse(await request('/api/v1/client/bootstrap' + (query.size ? `?${query}` : ''), access));
const expected = value.transport === 'openrouter-direct' ? 'https://openrouter.ai/api/v1' : `${origin}/v1`;
if (value.baseUrl !== expected) throw new GatewayError('invalid_gateway_response');
return value;
diff --git a/apps/daemon/src/gateway/config-store.ts b/apps/daemon/src/gateway/config-store.ts
index 9b5fea56..a722888b 100644
--- a/apps/daemon/src/gateway/config-store.ts
+++ b/apps/daemon/src/gateway/config-store.ts
@@ -2,14 +2,21 @@ import { join } from 'node:path';
import { randomUUID } from 'node:crypto';
import { z } from 'zod';
import { deletePrivateJsonFile, readPrivateJsonFile, writePrivateJsonFile } from '../config/private-json-file.js';
-import { bootstrapSchema, type GatewayBootstrap, type GatewayTokens } from './client.js';
-export type GatewayCredentials = Partial<GatewayBootstrap> & GatewayTokens & { accessExpiresAt: string };
+import { bootstrapCredentialsSchema, type GatewayBootstrap, type GatewayTokens } from './client.js';
+const modelAccessErrorSchema = z.enum(['auth_required', 'account_disabled', 'payment_review_required']);
+export type GatewayCredentials = Partial<GatewayBootstrap> & GatewayTokens & { accessExpiresAt: string; modelAccessError?: z.infer<typeof modelAccessErrorSchema> };
export function createGatewayConfigStore(dataDir: string) {
const secretPath = join(dataDir, 'config', 'gateway-credentials.json');
const publicPath = join(dataDir, 'config', 'gateway.json');
const devicePath = join(dataDir, 'config', 'gateway-device.json');
let deviceID: Promise<string> | undefined;
- const credentials = bootstrapSchema.partial().extend({ accessToken: z.string(), refreshToken: z.string(), expiresIn: z.number(), accessExpiresAt: z.string() });
+ let credentialMutation = Promise.resolve();
+ function mutateCredentials(work: () => Promise<void>) {
+ const result = credentialMutation.then(work);
+ credentialMutation = result.catch(() => undefined);
+ return result;
+ }
+ const credentials = bootstrapCredentialsSchema.partial().extend({ accessToken: z.string(), refreshToken: z.string(), expiresIn: z.number(), accessExpiresAt: z.string(), modelAccessError: modelAccessErrorSchema.optional() });
const configuration = z.object({ source: z.enum(['manual', 'gateway']), bindingVersion: z.string().nullable(), explicitlySelected: z.boolean().optional(), selectedModels: z.record(z.string()).optional() });
return {
readDeviceID(): Promise<string> {
@@ -20,8 +27,8 @@ export function createGatewayConfigStore(dataDir: string) {
})();
},
async readCredentials(): Promise<GatewayCredentials | undefined> { const value = await readPrivateJsonFile(secretPath); return value === undefined ? undefined : credentials.parse(value); },
- writeCredentials(value: GatewayCredentials) { return writePrivateJsonFile(secretPath, value); },
- deleteCredentials() { return deletePrivateJsonFile(secretPath); },
+ writeCredentials(value: GatewayCredentials) { return mutateCredentials(() => writePrivateJsonFile(secretPath, value)); },
+ deleteCredentials() { return mutateCredentials(() => deletePrivateJsonFile(secretPath)); },
async readConfiguration() { const value = await readPrivateJsonFile(publicPath); return value === undefined ? { source: 'manual' as const, bindingVersion: null } : configuration.parse(value); },
writeConfiguration(value: z.infer<typeof configuration>) { return writePrivateJsonFile(publicPath, value); }
};
diff --git a/apps/daemon/src/gateway/creator-service-source.ts b/apps/daemon/src/gateway/creator-service-source.ts
index 9b9f2a2f..daafdc80 100644
--- a/apps/daemon/src/gateway/creator-service-source.ts
+++ b/apps/daemon/src/gateway/creator-service-source.ts
@@ -17,7 +17,7 @@ const bindings = new WeakMap<CreatorServicesConfig, GatewayCreatorBinding>();
export function gatewayCreatorBinding(config: CreatorServicesConfig) { return bindings.get(config); }
export function createGatewayCreatorSource(input: {
- account: Pick<GatewayAccountService, 'peekState' | 'modelCredentials'> & Partial<Pick<GatewayAccountService, 'beginModelUse'>>;
+ account: Pick<GatewayAccountService, 'peekState' | 'modelCredentials'> & Partial<Pick<GatewayAccountService, 'beginModelUse' | 'recoverModelCredentials'>>;
manual: CreatorServicesConfigStore;
getLocalOrigin(): string | undefined;
fetcher?: typeof fetch;
@@ -33,7 +33,14 @@ export function createGatewayCreatorSource(input: {
const remoteTasks = new Set<string>();
const prefix = `${KRILLIN_LLM_ROUTE_PREFIX}/gateway/v1`;
const direct = input.directRequestsRoot ? createDirectTransport(input.directRequestsRoot,
- input.fetcher ?? createOfficialFetch({ readProxy: async () => (await input.manual.read()).proxy })) : undefined;
+ input.fetcher ?? createOfficialFetch({ readProxy: async () => (await input.manual.read()).proxy }),
+ input.account.recoverModelCredentials ? async (accountId, failedKey) => {
+ const current = await input.account.modelCredentials();
+ if (current.accountId !== accountId) throw new GatewayError('auth_required', 401);
+ const updated = current.modelKey !== failedKey ? current : await input.account.recoverModelCredentials!(current.keyVersion);
+ if (updated.accountId !== accountId) throw new GatewayError('auth_required', 401);
+ return updated.modelKey !== failedKey ? updated.modelKey : undefined;
+ } : undefined) : undefined;
function snapshot(): CreatorServiceBinding {
const state = input.account.peekState();
if (state.source === 'manual') return { source: 'manual' };
@@ -142,7 +149,19 @@ export function createGatewayCreatorSource(input: {
inFlight.set(controller, new Promise<void>(resolve => { complete = resolve; }));
let streaming = false;
let releaseUse: (() => Promise<void>) | undefined;
- const finish = () => { inFlight.delete(controller); void releaseUse?.(); releaseUse = undefined; complete(); };
+ const chatStream = request.method === 'POST' && resource === 'chat/completions' && (request.body as { stream?: unknown })?.stream === true;
+ let heartbeat: NodeJS.Timeout | undefined;
+ const disconnected = () => { if (!reply.raw.writableFinished) controller.abort(); };
+ const finish = () => {
+ clearInterval(heartbeat); reply.raw.removeListener('close', disconnected);
+ inFlight.delete(controller); void releaseUse?.(); releaseUse = undefined; complete();
+ };
+ const sendStreamError = (error: unknown) => {
+ if (!reply.raw.destroyed && !reply.raw.writableEnded) reply.raw.end(`data: ${JSON.stringify({ error: {
+ code: error instanceof GatewayError ? error.code : 'gateway_unavailable',
+ message: 'Official service request could not be completed'
+ } })}\n\n`);
+ };
let receipt: CreatorProviderRequest | undefined;
let reconcile = async () => {};
const markUnknown = () => {
@@ -151,13 +170,25 @@ export function createGatewayCreatorSource(input: {
if (receipt && ['submitting', 'waiting_remote'].includes(receipt.status)) receipt = input.ledger.markUnknownRemoteAcceptance(receipt.id);
};
try {
+ // 提前建立 SSE 连接,避免账号协调和上游准备耗尽 Krillin 的响应头等待时间。
+ if (chatStream) {
+ reply.hijack();
+ reply.raw.writeHead(200, { 'Content-Type': 'text/event-stream; charset=utf-8', 'Cache-Control': 'no-cache, no-store, no-transform', connection: 'keep-alive', 'X-Accel-Buffering': 'no' });
+ reply.raw.write(': connected\n\n');
+ reply.raw.once('close', disconnected);
+ heartbeat = setInterval(() => { if (!reply.raw.destroyed && !reply.raw.writableEnded) reply.raw.write(': keep-alive\n\n'); }, 10_000);
+ heartbeat.unref();
+ }
const use = await input.account.beginModelUse?.(); releaseUse = use?.release;
+ signal.throwIfAborted();
const credentials = use?.credentials ?? await input.account.modelCredentials();
+ signal.throwIfAborted();
if (capabilities.get(original.token) !== original || credentials.accountId !== original.accountId) throw new GatewayError('auth_required', 401);
const headers: Record<string,string> = { Authorization: `Bearer ${credentials.modelKey}`, 'Content-Type': request.headers['content-type'] ?? 'application/json' };
const identity = request.headers['idempotency-key'];
const body = request.method === 'GET' ? undefined : Buffer.isBuffer(request.body) ? new Uint8Array(request.body) : JSON.stringify(request.body);
const digest = request.method === 'POST' && (credentials.transport === 'openrouter-direct' || (original.logicalId && typeof identity !== 'string')) ? await requestDigest(request.body, headers['Content-Type']!) : undefined;
+ signal.throwIfAborted();
if (request.method === 'POST') headers['Idempotency-Key'] = typeof identity === 'string' ? identity : original.logicalId
? `creator:${createHash('sha256').update(JSON.stringify([original.logicalId, resource, digest])).digest('hex')}`
: randomUUID();
@@ -199,9 +230,12 @@ export function createGatewayCreatorSource(input: {
response = await direct.request({ account: credentials.accountId, key: credentials.modelKey, resource, method: request.method, body: request.body, contentType: headers['Content-Type']!, identity: headers['Idempotency-Key'] ?? '', fingerprint: digest ?? '', signal, model: modelMetadata, asyncImage: request.headers.prefer === 'respond-async' });
} else response = await (input.fetcher ?? fetch)(`${credentials.baseUrl}/${resource}`, { method: request.method, headers, body, redirect: 'error', signal });
signal.throwIfAborted();
- reply.code(response.status).header('Cache-Control', 'no-store');
- reply.header('Content-Type', response.headers.get('content-type') ?? 'application/json');
- const id = response.headers.get('x-request-id'); if (id) reply.header('X-Request-ID', id);
+ const id = response.headers.get('x-request-id');
+ if (!chatStream) {
+ reply.code(response.status).header('Cache-Control', 'no-store');
+ reply.header('Content-Type', response.headers.get('content-type') ?? 'application/json');
+ if (id) reply.header('X-Request-ID', id);
+ }
if (receipt && input.ledger) {
receipt = input.ledger.findLatest(receipt.provider, receipt.requestKey);
if (receipt && ['submitting', 'waiting_remote', 'unknown_remote_acceptance'].includes(receipt.status)) {
@@ -228,6 +262,10 @@ export function createGatewayCreatorSource(input: {
}
return value;
}
+ if (chatStream && (!response.ok || !response.headers.get('content-type')?.includes('text/event-stream'))) {
+ await response.body?.cancel();
+ throw new GatewayError(response.ok ? 'invalid_gateway_response' : 'official_service_unavailable', response.ok ? 503 : response.status);
+ }
if (!response.body) return reply.send();
const stream = Readable.fromWeb(response.body as import('node:stream/web').ReadableStream);
streaming = true;
@@ -235,10 +273,16 @@ export function createGatewayCreatorSource(input: {
const abort = () => stream.destroy(new Error('Official service forwarding was interrupted'));
signal.addEventListener('abort', abort, { once: true });
stream.once('close', () => signal.removeEventListener('abort', abort));
+ if (chatStream) {
+ stream.once('error', sendStreamError);
+ stream.pipe(reply.raw);
+ return reply;
+ }
return reply.send(stream);
} catch (error) {
if (receipt && input.ledger && error instanceof GatewayError && [400, 401, 402, 403, 404, 422, 429].includes(error.status) && ['submitting', 'waiting_remote'].includes(receipt.status)) receipt = input.ledger.markFailed(receipt.id);
else markUnknown();
+ if (chatStream) { sendStreamError(error); return reply; }
return reply.code(error instanceof GatewayError ? error.status : 503).send({ error: { code: error instanceof GatewayError ? error.code : 'gateway_unavailable', message: 'Official service request could not be completed' } });
} finally { if (!streaming) finish(); }
} });
diff --git a/apps/daemon/src/gateway/direct-runtime.ts b/apps/daemon/src/gateway/direct-runtime.ts
index 0cfaca53..87734e9a 100644
--- a/apps/daemon/src/gateway/direct-runtime.ts
+++ b/apps/daemon/src/gateway/direct-runtime.ts
@@ -4,8 +4,9 @@ import { Readable } from 'node:stream';
import { pipeline } from 'node:stream/promises';
import { statelessResponses } from './direct-transport.js';
import { officialEventStream } from './official-stream.js';
+import { GatewayError } from './client.js';
-export async function createDirectRuntime(key: string, fetcher: typeof fetch = fetch, beginUse?: () => Promise<{ key: string; release(): Promise<void> }>) {
+export async function createDirectRuntime(key: string, fetcher: typeof fetch = fetch, beginUse?: () => Promise<{ key: string; keyVersion?: string; release(): Promise<void> }>, recoverKey?: (keyVersion: string) => Promise<{ key: string; keyVersion: string }>) {
const token = `oclocal_${randomBytes(32).toString('base64url')}`;
const active = new Set<AbortController>();
const handlers = new Set<Promise<void>>();
@@ -21,16 +22,32 @@ export async function createDirectRuntime(key: string, fetcher: typeof fetch = f
for await (const chunk of req) { size += chunk.length; if (size > 64 * 1024 * 1024) throw new Error('Request too large'); chunks.push(Buffer.from(chunk)); }
const body = statelessResponses(JSON.parse(Buffer.concat(chunks).toString('utf8')) as Record<string, unknown>);
const use = await beginUse?.(); release = use?.release;
- const response = await fetcher('https://openrouter.ai/api/v1/responses', { method: 'POST', redirect: 'error', signal: AbortSignal.any([controller.signal, AbortSignal.timeout(180_000)]), headers: { Authorization: `Bearer ${use?.key ?? key}`, 'Content-Type': 'application/json' }, body: JSON.stringify(body) });
+ const signal = AbortSignal.any([controller.signal, AbortSignal.timeout(180_000)]);
+ const submit = (modelKey: string) => {
+ signal.throwIfAborted();
+ return fetcher('https://openrouter.ai/api/v1/responses', { method: 'POST', redirect: 'error', signal, headers: { Authorization: `Bearer ${modelKey}`, 'Content-Type': 'application/json' }, body: JSON.stringify(body) });
+ };
+ let response = await submit(use?.key ?? key);
+ if (response.status === 401 && use?.keyVersion && recoverKey) {
+ await response.body?.cancel();
+ let updated: { key: string; keyVersion: string };
+ try { updated = await recoverKey(use.keyVersion); }
+ catch (error) {
+ signal.throwIfAborted();
+ throw error instanceof GatewayError && [401, 403].includes(error.status) ? error : new GatewayError('model_auth_required', 401);
+ }
+ if (updated.keyVersion !== use.keyVersion) response = await submit(updated.key);
+ }
if (!response.ok || !response.body) {
await response.body?.cancel();
- res.writeHead(response.status === 402 ? 402 : 503, { 'Content-Type': 'application/json' }).end(JSON.stringify({ error: { message: response.status === 402 ? '积分不足' : '官方模型服务暂不可用' } })); return;
+ res.writeHead([401, 402].includes(response.status) ? response.status : 503, { 'Content-Type': 'application/json' }).end(JSON.stringify({ error: { message: response.status === 401 ? '官方模型凭据已失效,请重新连接账号' : response.status === 402 ? '积分不足' : '官方模型服务暂不可用' } })); return;
}
res.writeHead(200, { 'Content-Type': response.headers.get('content-type') ?? 'text/event-stream', 'Cache-Control': 'no-store' });
const bodyStream = response.headers.get('content-type')?.includes('text/event-stream') ? officialEventStream(response.body) : response.body;
await pipeline(Readable.fromWeb(bodyStream as import('node:stream/web').ReadableStream), res);
- } catch {
- if (!res.headersSent) res.writeHead(503, { 'Content-Type': 'application/json' }).end(JSON.stringify({ error: { message: '官方模型服务暂不可用' } }));
+ } catch (error) {
+ const status = error instanceof GatewayError && [401, 403].includes(error.status) ? error.status : 503;
+ if (!res.headersSent) res.writeHead(status, { 'Content-Type': 'application/json' }).end(JSON.stringify({ error: { message: status === 401 ? '官方模型凭据已失效,请重新连接账号' : status === 403 ? '官方模型服务暂不可用,请检查账号状态' : '官方模型服务暂不可用' } }));
else res.destroy();
} finally {
try { await release?.(); }
diff --git a/apps/daemon/src/gateway/direct-transport.ts b/apps/daemon/src/gateway/direct-transport.ts
index 7d278861..ad90ed18 100644
--- a/apps/daemon/src/gateway/direct-transport.ts
+++ b/apps/daemon/src/gateway/direct-transport.ts
@@ -57,7 +57,7 @@ export function statelessResponses(body: Record<string, unknown>) {
return { ...rest, store: false };
}
-export function createDirectTransport(root: string, fetcher: typeof fetch = fetch) {
+export function createDirectTransport(root: string, fetcher: typeof fetch = fetch, recoverKey?: (account: string, failedKey: string) => Promise<string | undefined>) {
const pending = new Map<string, Promise<Response>>();
const fingerprints = new Map<string, string>();
const workers = new Map<string, AbortController>();
@@ -75,13 +75,27 @@ export function createDirectTransport(root: string, fetcher: typeof fetch = fetc
const write = (id: string, record: Receipt) => writePrivateJsonFile(path(id), record);
const response = (id: string, record: Receipt) => new Response(Buffer.from(record.content ?? '', 'base64'), { status: record.status ?? 200, headers: { 'Content-Type': record.mime ?? 'application/json', 'X-Request-ID': id } });
const accepted = (id: string) => Response.json({ requestId: id, state: 'waiting_upstream' }, { status: 202, headers: { 'X-Request-ID': id } });
- async function call(resource: string, options: RequestInit, key: string) {
- const work = fetcher(`${base}/${resource}`, { ...options, redirect: 'error', headers: { ...options.headers, Authorization: `Bearer ${key}` } });
- let result: Response;
- try { result = options.signal ? await abortable(work, options.signal) : await work; }
- catch (error) {
- void work.then(value => value.body?.cancel()).catch(() => undefined);
- throw error;
+ async function call(resource: string, options: RequestInit, key: string, account: string) {
+ const submit = async (modelKey: string) => {
+ options.signal?.throwIfAborted();
+ const work = fetcher(`${base}/${resource}`, { ...options, redirect: 'error', headers: { ...options.headers, Authorization: `Bearer ${modelKey}` } });
+ try { return options.signal ? await abortable(work, options.signal) : await work; }
+ catch (error) {
+ void work.then(value => value.body?.cancel()).catch(() => undefined);
+ throw error;
+ }
+ };
+ let result = await submit(key);
+ if (result.status === 401 && recoverKey) {
+ await result.body?.cancel();
+ const recovery = recoverKey(account, key);
+ let updated: string | undefined;
+ try { updated = options.signal ? await abortable(recovery, options.signal) : await recovery; }
+ catch (error) {
+ options.signal?.throwIfAborted();
+ throw error instanceof GatewayError && [401, 403].includes(error.status) ? error : new GatewayError('model_auth_required', 401);
+ }
+ if (updated && updated !== key) result = await submit(updated);
}
if (!result.ok) {
let limitExceeded = false;
@@ -91,7 +105,7 @@ export function createDirectTransport(root: string, fetcher: typeof fetch = fetc
limitExceeded = typeof payload.error?.message === 'string' && /^Key limit exceeded\b/i.test(payload.error.message);
} catch {}
} else void result.body?.cancel().catch(() => undefined);
- throw new GatewayError(result.status === 402 || limitExceeded ? 'credits_insufficient' : 'official_service_unavailable', result.status >= 400 && result.status < 500 ? result.status : 503);
+ throw new GatewayError(result.status === 401 ? 'model_auth_required' : result.status === 402 || limitExceeded ? 'credits_insufficient' : 'official_service_unavailable', result.status >= 400 && result.status < 500 ? result.status : 503);
}
return result;
}
@@ -117,9 +131,9 @@ export function createDirectTransport(root: string, fetcher: typeof fetch = fetc
if (record.remoteId) {
if (lookup[2]) {
if (record.state !== 'succeeded') throw new GatewayError('request_outcome_unknown', 409);
- return call(`videos/${encodeURIComponent(record.remoteId)}/content?index=0`, { method: 'GET', signal }, key);
+ return call(`videos/${encodeURIComponent(record.remoteId)}/content?index=0`, { method: 'GET', signal }, key, account);
}
- const remote = await (await call(`videos/${encodeURIComponent(record.remoteId)}`, { method: 'GET', signal }, key)).json() as { status?: string };
+ const remote = await (await call(`videos/${encodeURIComponent(record.remoteId)}`, { method: 'GET', signal }, key, account)).json() as { status?: string };
record.state = remote.status === 'completed' ? 'succeeded' : ['failed', 'cancelled', 'expired'].includes(remote.status ?? '') ? 'failed' : 'waiting_upstream';
await write(id, record);
}
@@ -186,7 +200,7 @@ export function createDirectTransport(root: string, fetcher: typeof fetch = fetc
await write(id, record);
registered();
try {
- const remote = await call(endpoint, { method: 'POST', signal, headers: { 'Content-Type': contentType }, body: Buffer.isBuffer(body) ? new Uint8Array(body) : JSON.stringify(body) }, key);
+ const remote = await call(endpoint, { method: 'POST', signal, headers: { 'Content-Type': contentType }, body: Buffer.isBuffer(body) ? new Uint8Array(body) : JSON.stringify(body) }, key, account);
if (endpoint === 'videos') {
const value = await remote.json() as { id?: string };
if (!value.id || !/^[A-Za-z0-9_-]{1,200}$/.test(value.id)) throw new GatewayError('invalid_gateway_response');
diff --git a/apps/daemon/src/gateway/runtime-bindings.ts b/apps/daemon/src/gateway/runtime-bindings.ts
index 0e43d33d..539f2da1 100644
--- a/apps/daemon/src/gateway/runtime-bindings.ts
+++ b/apps/daemon/src/gateway/runtime-bindings.ts
@@ -13,7 +13,8 @@ export type GatewayRuntimeBindingsInput = {
parentEnvironment?: NodeJS.ProcessEnv;
direct?: boolean;
readProxy?(): Promise<string>;
- beginUse?(): Promise<{ key: string; release(): Promise<void> }>;
+ beginUse?(): Promise<{ key: string; keyVersion?: string; release(): Promise<void> }>;
+ recoverKey?(keyVersion: string): Promise<{ key: string; keyVersion: string }>;
};
export type GatewayRuntimePreparation = {
@@ -53,7 +54,7 @@ export function createGatewayRuntimeBindings(input: GatewayRuntimeBindingsInput)
}
if (input.direct) {
if (input.baseUrl !== 'https://openrouter.ai/api/v1') throw new Error('Invalid official endpoint');
- connection ??= await createDirectRuntime(credentials.modelKey, createOfficialFetch({ readProxy: input.readProxy }), input.beginUse);
+ connection ??= await createDirectRuntime(credentials.modelKey, createOfficialFetch({ readProxy: input.readProxy }), input.beginUse, input.recoverKey);
assertOpen(preparingGeneration);
}
mkdirSync(input.codexHome, { recursive: true, mode: 0o700 });
diff --git a/apps/daemon/test/integration/direct-credential-recovery.test.ts b/apps/daemon/test/integration/direct-credential-recovery.test.ts
new file mode 100644
index 00000000..44d6abc9
--- /dev/null
+++ b/apps/daemon/test/integration/direct-credential-recovery.test.ts
@@ -0,0 +1,112 @@
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, expect, it, vi } from 'vitest';
+import { createDirectTransport } from '../../src/gateway/direct-transport.js';
+import { GatewayError } from '../../src/gateway/client.js';
+import Fastify from 'fastify';
+import { createDefaultCreatorServicesConfig } from '@opencreator/protocol';
+import { createGatewayCreatorSource } from '../../src/gateway/creator-service-source.js';
+import type { GatewayAccountService } from '../../src/gateway/account-service.js';
+
+const cleanup: Array<() => Promise<void>> = [];
+afterEach(async () => { for (const close of cleanup.splice(0).reverse()) await close(); });
+async function fixture(fetcher: typeof fetch, recover = vi.fn(async (_account: string, _failedKey: string): Promise<string | undefined> => 'new-key')) {
+ const root = await mkdtemp(join(tmpdir(), 'oc-credential-recovery-'));
+ const transport = createDirectTransport(root, fetcher, recover);
+ cleanup.push(() => rm(root, { recursive: true, force: true })); cleanup.push(() => transport.close());
+ const request = (resource = 'chat/completions', asyncImage = false) => transport.request({ account: 'a', key: 'old-key', resource, asyncImage, method: resource.startsWith('requests/') ? 'GET' : 'POST', body: { model: 'test/model', prompt: 'test' }, contentType: 'application/json', identity: 'same-operation', fingerprint: 'same-input', signal: new AbortController().signal });
+ return { transport, recover, request };
+}
+
+it.each(['chat/completions', 'images/generations', 'video/jobs'])('%s 明确拒绝认证后只重试一次,同一请求复用结果', async resource => {
+ const fetcher = vi.fn<typeof fetch>().mockResolvedValueOnce(Response.json({}, { status: 401 })).mockImplementation(async () => Response.json(resource.startsWith('images') ? { data: [{ b64_json: 'aW1hZ2U=' }] } : resource === 'video/jobs' ? { id: 'video-upstream' } : { choices: [{ message: { content: 'translated' } }] }));
+ const f = await fixture(fetcher);
+ const asyncImage = resource.startsWith('images');
+ const first = await f.request(resource, asyncImage);
+ const id = first.headers.get('x-request-id')!;
+ if (asyncImage) {
+ expect(first.status).toBe(202);
+ await vi.waitFor(async () => expect(await (await f.request(`requests/${id}`)).json()).toMatchObject({ state: 'succeeded' }));
+ expect(await (await f.request(`requests/${id}/result`)).json()).toMatchObject({ data: [{ b64_json: 'aW1hZ2U=' }] });
+ }
+ await (await f.request(resource, asyncImage)).text();
+ expect(f.recover).toHaveBeenCalledExactlyOnceWith('a', 'old-key');
+ expect(fetcher).toHaveBeenCalledTimes(2);
+ expect(fetcher.mock.calls.map(([, options]) => new Headers(options?.headers).get('authorization'))).toEqual(['Bearer old-key', 'Bearer new-key']);
+ expect(fetcher.mock.calls[0]![1]!.body).toEqual(fetcher.mock.calls[1]![1]!.body);
+});
+
+it('恢复后的新密钥仍被拒绝时不继续重试', async () => {
+ const fetcher = vi.fn<typeof fetch>().mockImplementation(async () => Response.json({}, { status: 401 }));
+ const f = await fixture(fetcher);
+ await expect(f.request()).rejects.toMatchObject({ code: 'model_auth_required', status: 401 });
+ expect(fetcher).toHaveBeenCalledTimes(2); expect(f.recover).toHaveBeenCalledOnce();
+});
+
+it.each([402, 403, 503, 'network'] as const)('上游 %s 不触发密钥恢复或自动重发', async status => {
+ const fetcher = vi.fn<typeof fetch>().mockImplementation(async () => {
+ if (status === 'network') throw new Error('Network lost');
+ return Response.json({}, { status });
+ });
+ const f = await fixture(fetcher);
+ await expect(f.request()).rejects.toThrow();
+ expect(fetcher).toHaveBeenCalledOnce(); expect(f.recover).not.toHaveBeenCalled();
+ if (status === 503 || status === 'network') {
+ await expect(f.request()).rejects.toMatchObject({ code: 'request_outcome_unknown' });
+ expect(fetcher).toHaveBeenCalledOnce();
+ }
+});
+
+it('明确认证拒绝后网关无法恢复时记录为失败,不误记为上游结果未知', async () => {
+ const fetcher = vi.fn<typeof fetch>().mockImplementation(async () => Response.json({}, { status: 401 }));
+ const recover = vi.fn(async (_account: string, _key: string): Promise<string | undefined> => { throw new GatewayError('gateway_unavailable'); });
+ const f = await fixture(fetcher, recover);
+ const response = await f.request('images/generations', true);
+ const id = response.headers.get('x-request-id')!;
+ await vi.waitFor(async () => expect(await (await f.request(`requests/${id}`)).json()).toMatchObject({ state: 'failed', error: { code: 'model_auth_required' } }));
+ expect(fetcher).toHaveBeenCalledOnce();
+});
+
+it('流已开始后报告错误时保留未知结果,不换密钥重发', async () => {
+ const fetcher = vi.fn<typeof fetch>().mockImplementation(async () => new Response('data: {"choices":[{"delta":{"content":"partial"}}]}\n\ndata: {"error":{"code":401,"message":"failed"}}\n\n', { headers: { 'Content-Type': 'text/event-stream' } }));
+ const f = await fixture(fetcher);
+ const response = await f.request();
+ await expect(response.text()).rejects.toMatchObject({ code: 'request_outcome_unknown' });
+ await expect(f.request()).rejects.toMatchObject({ code: 'request_outcome_unknown' });
+ expect(fetcher).toHaveBeenCalledOnce(); expect(f.recover).not.toHaveBeenCalled();
+});
+
+it.each(['updated', 'account-changed'] as const)('异步图片在返回 202 后通过共享账号恢复凭据(%s)', async outcome => {
+ const root = await mkdtemp(join(tmpdir(), 'oc-source-recovery-'));
+ cleanup.push(() => rm(root, { recursive: true, force: true }));
+ const models = [{ id: 'test/image', modality: 'image' as const, capabilities: [] }];
+ const defaults = { image: 'test/image' };
+ const credentials = { accountId: 'a', modelKey: 'old-key', keyVersion: '1', bindingVersion: 'a:1', baseUrl: 'https://openrouter.ai/api/v1', transport: 'openrouter-direct' as const, models, defaults };
+ const release = vi.fn(async () => undefined);
+ const recover = vi.fn(async () => ({ ...credentials, accountId: outcome === 'account-changed' ? 'b' : 'a', modelKey: 'new-key', keyVersion: '2' }));
+ const account: Pick<GatewayAccountService, 'peekState' | 'modelCredentials' | 'beginModelUse' | 'recoverModelCredentials'> = {
+ peekState: () => ({ source: 'gateway', authState: 'signed_in', activationState: 'ready', account: { id: 'a', email: 'a@test', verified: true }, bindingVersion: 'a:1', models, selectedModels: defaults, activationError: null }),
+ modelCredentials: async () => credentials, beginModelUse: async () => ({ credentials, release }), recoverModelCredentials: recover
+ };
+ let resume!: () => void;
+ const waiting = new Promise<void>(resolve => { resume = resolve; });
+ const fetcher = vi.fn<typeof fetch>().mockImplementationOnce(async () => { await waiting; return Response.json({}, { status: 401 }); }).mockImplementation(async () => Response.json({ data: [{ b64_json: 'aW1hZ2U=' }] }));
+ const manual = createDefaultCreatorServicesConfig();
+ const source = createGatewayCreatorSource({ account, directRequestsRoot: root, manual: { read: async () => manual, write: async value => value, reset: async () => manual }, getLocalOrigin: () => 'http://127.0.0.1:39999', fetcher });
+ const server = Fastify();
+ cleanup.push(() => server.close()); cleanup.push(() => source.revoke());
+ await source.register(server);
+ const config = await source.store.read();
+ const headers = { authorization: `Bearer ${config.llm.apiKey}`, prefer: 'respond-async', 'idempotency-key': 'same-image' };
+ try {
+ const accepted = await server.inject({ method: 'POST', url: '/internal/krillin-llm/gateway/v1/images/generations', headers, payload: { model: 'test/image', prompt: 'test' } });
+ expect(accepted.statusCode).toBe(202);
+ await vi.waitFor(() => expect(release).toHaveBeenCalledOnce());
+ resume();
+ const url = `/internal/krillin-llm/gateway/v1/requests/${accepted.json().requestId}`;
+ await vi.waitFor(async () => expect((await server.inject({ url, headers })).json()).toMatchObject({ state: outcome === 'updated' ? 'succeeded' : 'failed' }));
+ expect(recover).toHaveBeenCalledExactlyOnceWith('1');
+ expect(fetcher).toHaveBeenCalledTimes(outcome === 'updated' ? 2 : 1);
+ } finally { resume(); }
+});
diff --git a/apps/daemon/test/integration/direct-services.test.ts b/apps/daemon/test/integration/direct-services.test.ts
index 880ac091..3f111c07 100644
--- a/apps/daemon/test/integration/direct-services.test.ts
+++ b/apps/daemon/test/integration/direct-services.test.ts
@@ -5,6 +5,7 @@ import { tmpdir } from 'node:os';
import { afterEach, expect, it, vi } from 'vitest';
import { createDefaultCreatorServicesConfig, gatewayDefaultVoiceId, type GatewayModel } from '@opencreator/protocol';
import { createGatewayCreatorSource } from '../../src/gateway/creator-service-source.js';
+import type { GatewayAccountService } from '../../src/gateway/account-service.js';
import { createDirectTransport } from '../../src/gateway/direct-transport.js';
import { createDirectRuntime } from '../../src/gateway/direct-runtime.js';
import { registerCreatorServicesRoutes } from '../../src/api/routes.creator-services.js';
@@ -51,14 +52,89 @@ async function fixture(ledger?: CreatorProviderRequestLedger) {
if (String(url).endsWith('/images')) return Response.json({ data: [{ b64_json: 'aW1hZ2U=' }] });
return Response.json({ choices: [{ message: { content: 'text result' } }] });
}) as typeof fetch;
- const source = createGatewayCreatorSource({ directRequestsRoot: join(root, 'receipts'), ledger,
- account: { peekState: () => state, modelCredentials: async () => ({ accountId: 'a', bindingVersion: 'a:1', keyVersion: '1', modelKey: 'private-user-key', baseUrl: 'https://openrouter.ai/api/v1', transport: 'openrouter-direct', models, defaults }) },
+ const account: Pick<GatewayAccountService, 'peekState' | 'modelCredentials'> & Partial<Pick<GatewayAccountService, 'beginModelUse'>> = {
+ peekState: () => state, modelCredentials: async () => ({ accountId: 'a', bindingVersion: 'a:1', keyVersion: '1', modelKey: 'private-user-key', baseUrl: 'https://openrouter.ai/api/v1', transport: 'openrouter-direct', models, defaults })
+ };
+ const source = createGatewayCreatorSource({ directRequestsRoot: join(root, 'receipts'), ledger, account,
manual: { read: async () => structuredClone(manual), write: async config => config, reset: async () => manual }, getLocalOrigin: () => 'http://127.0.0.1:39999', fetcher
});
const server = Fastify(); cleanup.push(() => server.close()); cleanup.push(() => source.revoke());
await source.register(server); await registerCreatorServicesRoutes(server, source.store);
- return { server, source, fetcher, state, manual, root };
+ return { server, source, fetcher, state, manual, root, account };
}
+it.each(['account', 'headers', 'first-token'])('opens the translation stream before slow %s preparation and reuses the completed result', async delayed => {
+ const f = await fixture();
+ const origin = await f.server.listen({ host: '127.0.0.1', port: 0 });
+ const config = await f.source.store.read();
+ let resume!: () => void;
+ const waiting = new Promise<void>(resolve => { resume = resolve; });
+ const release = vi.fn(async () => undefined);
+ f.account.beginModelUse = async () => {
+ if (delayed === 'account') await waiting;
+ return { credentials: await f.account.modelCredentials(), release };
+ };
+ vi.mocked(f.fetcher).mockImplementation(async () => {
+ if (delayed === 'headers') await waiting;
+ return new Response(new ReadableStream<Uint8Array>({ async start(controller) {
+ if (delayed === 'first-token') await waiting;
+ controller.enqueue(new TextEncoder().encode('data: {"choices":[{"delta":{"content":"translated"}}]}\n\ndata: [DONE]\n\n'));
+ controller.close();
+ } }), { headers: { 'Content-Type': 'text/event-stream' } });
+ });
+ const submit = () => fetch(`${origin}/internal/krillin-llm/gateway/v1/chat/completions`, {
+ method: 'POST', headers: { Authorization: `Bearer ${config.llm.apiKey}`, 'Content-Type': 'application/json', 'Idempotency-Key': 'same-translation' },
+ body: JSON.stringify({ model: 'vendor/text', messages: [], stream: true }), signal: AbortSignal.timeout(2_000)
+ });
+ try {
+ const response = await submit();
+ expect(response.status).toBe(200);
+ const reader = response.body!.getReader();
+ expect(new TextDecoder().decode((await reader.read()).value)).toContain(': connected');
+ if (delayed === 'account') expect(f.fetcher).not.toHaveBeenCalled();
+ resume();
+ let content = '';
+ for (;;) { const chunk = await reader.read(); if (chunk.done) break; content += new TextDecoder().decode(chunk.value); }
+ expect(content).toContain('[DONE]');
+ reader.releaseLock();
+ await vi.waitFor(() => expect(release).toHaveBeenCalledOnce());
+ expect(await (await submit()).text()).toContain('translated');
+ expect(f.fetcher).toHaveBeenCalledOnce();
+ await vi.waitFor(() => expect(f.source.isBusy()).toBe(false));
+ } finally { resume(); }
+});
+it('does not submit a paid translation after the caller disconnects during account preparation', async () => {
+ const f = await fixture();
+ const origin = await f.server.listen({ host: '127.0.0.1', port: 0 });
+ const config = await f.source.store.read();
+ let resume!: () => void;
+ const waiting = new Promise<void>(resolve => { resume = resolve; });
+ const release = vi.fn(async () => undefined);
+ f.account.beginModelUse = async () => { await waiting; return { credentials: await f.account.modelCredentials(), release }; };
+ const disconnected = new Promise<void>(resolve => f.server.server.once('request', (_request, response) => response.once('close', resolve)));
+ try {
+ const response = await fetch(`${origin}/internal/krillin-llm/gateway/v1/chat/completions`, {
+ method: 'POST', headers: { Authorization: `Bearer ${config.llm.apiKey}`, 'Content-Type': 'application/json' },
+ body: JSON.stringify({ model: 'vendor/text', messages: [], stream: true }), signal: AbortSignal.timeout(2_000)
+ });
+ await response.body!.cancel();
+ await disconnected;
+ resume();
+ await vi.waitFor(() => expect(release).toHaveBeenCalledOnce());
+ await vi.waitFor(() => expect(f.source.isBusy()).toBe(false));
+ expect(f.fetcher).not.toHaveBeenCalled();
+ } finally { resume(); }
+});
+it('reports rejected streaming translations without exposing upstream details', async () => {
+ const f = await fixture();
+ const config = await f.source.store.read();
+ vi.mocked(f.fetcher).mockImplementation(async () => Response.json({ error: { message: 'OpenRouter private failure' } }, { status: 402 }));
+ const response = await f.server.inject({ method: 'POST', url: '/internal/krillin-llm/gateway/v1/chat/completions',
+ headers: { Authorization: `Bearer ${config.llm.apiKey}` }, payload: { model: 'vendor/text', messages: [], stream: true } });
+ expect(response.statusCode).toBe(200);
+ expect(response.body).toContain('credits_insufficient');
+ expect(response.body).not.toMatch(/OpenRouter|private-user-key|private failure/);
+ await vi.waitFor(() => expect(f.source.isBusy()).toBe(false));
+});
it('reconciles a streamed chat result without creating an unknown-acceptance issue', async () => {
const root = await mkdtemp(join(tmpdir(), 'oc-direct-chat-ledger-'));
const db = openRuntimeDatabase(join(root, 'runtime.sqlite'));
diff --git a/apps/daemon/test/unit/gateway-account-service.test.ts b/apps/daemon/test/unit/gateway-account-service.test.ts
index 2e340089..612465a8 100644
--- a/apps/daemon/test/unit/gateway-account-service.test.ts
+++ b/apps/daemon/test/unit/gateway-account-service.test.ts
@@ -51,6 +51,303 @@ async function seedSavedAccount(f: Awaited<ReturnType<typeof setup>>) {
return bootstrap;
}
+async function setupCachedAccount(overrides: Partial<GatewayBootstrap> = {}) {
+ const f = await setup();
+ const bootstrap: GatewayBootstrap = { ...await f.client.bootstrap('access-1'), transport: 'openrouter-direct', baseUrl: 'https://openrouter.ai/api/v1', keyRotation: false, modelUsePolicy: 'cached-key-v1', ...overrides };
+ f.client.bootstrap.mockResolvedValue(bootstrap);
+ const grant = await f.service.startAuthorization();
+ await f.service.pollAuthorization(grant.attemptId);
+ return { ...f, bootstrap };
+}
+
+it('有效模型凭据下连续一百次调用不访问账号网关,账户令牌过期也不阻塞', async () => {
+ const f = await setupCachedAccount();
+ const request = vi.spyOn(f.client, 'request').mockRejectedValue(new GatewayError('gateway_unavailable'));
+ f.client.bootstrap.mockClear().mockRejectedValue(new GatewayError('gateway_unavailable'));
+ f.client.refresh.mockRejectedValue(new GatewayError('gateway_unavailable'));
+ const clock = vi.spyOn(Date, 'now').mockReturnValue(Date.now() + 16 * 60_000);
+ try {
+ for (let index = 0; index < 100; index++) {
+ const use = await f.service.beginModelUse();
+ expect(use.credentials.modelKey).toBe(f.bootstrap.modelKey);
+ await use.release(); await use.release();
+ }
+ expect(request).not.toHaveBeenCalled();
+ expect(f.client.refresh).not.toHaveBeenCalled();
+ expect(f.client.bootstrap).not.toHaveBeenCalled();
+ expect(f.service.peekState()).toMatchObject({ authState: 'signed_in', activationState: 'ready' });
+ expect((await createGatewayConfigStore(f.root).readCredentials())?.modelUsePolicy).toBe('cached-key-v1');
+ } finally { clock.mockRestore(); await f.service.close(); }
+});
+
+it('稳定密钥账号重启时从本地激活,账号网关离线不影响恢复', async () => {
+ const f = await setupCachedAccount();
+ await f.service.close();
+ f.client.bootstrap.mockClear().mockRejectedValue(new GatewayError('gateway_unavailable'));
+ f.client.refresh.mockRejectedValue(new GatewayError('gateway_unavailable'));
+ const activate = vi.fn(async () => undefined);
+ const restored = module.createGatewayAccountService({ dataDir: f.root, client: f.client, activateRuntime: activate, closeRuntime: async () => undefined, hasActiveTasks: () => false, automaticPolling: false, deferStartupActivation: true });
+ try {
+ await restored.initialize(); await restored.startBackgroundRestore();
+ const use = await restored.beginModelUse(); await use.release();
+ expect(activate).toHaveBeenCalledOnce();
+ expect(f.client.bootstrap).not.toHaveBeenCalled();
+ expect(f.client.refresh).not.toHaveBeenCalled();
+ } finally { await restored.close(); }
+});
+
+it('并发认证恢复只获取一次新密钥,旧调用保持凭据快照', async () => {
+ const f = await setupCachedAccount();
+ const first = await f.service.beginModelUse();
+ let resume!: () => void;
+ const waiting = new Promise<void>(resolve => { resume = resolve; });
+ f.client.bootstrap.mockClear().mockImplementation(async () => {
+ await waiting;
+ return { ...f.bootstrap, modelKey: 'replacement-model-key', keyVersion: '2' };
+ });
+ try {
+ const pending = Promise.all([f.service.recoverModelCredentials('1'), f.service.recoverModelCredentials('1')]);
+ await expect.poll(() => f.client.bootstrap.mock.calls.length).toBe(1);
+ resume();
+ const results = await pending;
+ expect(results.map(value => value.modelKey)).toEqual(['replacement-model-key', 'replacement-model-key']);
+ expect(first.credentials.modelKey).toBe(f.bootstrap.modelKey);
+ const next = await f.service.beginModelUse();
+ expect(next.credentials.modelKey).toBe('replacement-model-key');
+ await next.release(); await first.release();
+ await f.service.recoverModelCredentials('1');
+ expect(f.client.bootstrap).toHaveBeenCalledOnce();
+ } finally { resume(); await first.release(); await f.service.close(); }
+});
+
+it('活跃任务恢复密钥时保留模型目录,空闲后再应用新默认模型', async () => {
+ const f = await setupCachedAccount();
+ const use = await f.service.beginModelUse();
+ const next = { ...f.bootstrap, modelKey: 'new-key', keyVersion: '2', models: [{ id: 'new-text', modality: 'text' as const, capabilities: ['responses'] }], defaults: { text: 'new-text' } };
+ f.client.bootstrap.mockResolvedValue(next);
+ const request = vi.spyOn(f.client, 'request').mockImplementation(async path => path === '/api/v1/me' ? { account: f.bootstrap.account } : { models: next.models });
+ let clock: ReturnType<typeof vi.spyOn> | undefined;
+ try {
+ const updated = await f.service.recoverModelCredentials('1');
+ expect(updated).toMatchObject({ modelKey: 'new-key', defaults: f.bootstrap.defaults, models: f.bootstrap.models });
+ expect(f.activate).toHaveBeenCalledOnce();
+ await use.release();
+ clock = vi.spyOn(Date, 'now').mockReturnValue(Date.now() + 31_000);
+ await f.service.readState();
+ expect((await f.service.modelCredentials()).defaults.text).toBe('new-text');
+ expect(f.activate).toHaveBeenCalledTimes(2);
+ expect(request).toHaveBeenCalledWith('/api/v1/client/models', 'access-1');
+ } finally { clock?.mockRestore(); await use.release(); await f.service.close(); }
+});
+
+it.each(['binding-first', 'refresh-first'] as const)('绑定同步与令牌刷新并发时保留新密钥和新令牌(%s)', async order => {
+ const f = await setupCachedAccount();
+ let resumeBinding!: () => void;
+ let resumeRefresh!: () => void;
+ const bindingWaiting = new Promise<void>(resolve => { resumeBinding = resolve; });
+ const refreshWaiting = new Promise<void>(resolve => { resumeRefresh = resolve; });
+ f.client.bootstrap.mockClear().mockImplementation(async () => {
+ await bindingWaiting;
+ return { ...f.bootstrap, modelKey: 'replacement-model-key', keyVersion: '2', bindingVersion: '1:2' };
+ });
+ f.client.refresh.mockImplementation(async () => {
+ await refreshWaiting;
+ return { accessToken: 'new-access', refreshToken: 'new-refresh', expiresIn: 900 };
+ });
+ const request = vi.spyOn(f.client, 'request').mockImplementation(async (_path?: string, access?: string) => {
+ if (access !== 'new-access') throw new GatewayError('auth_required', 401);
+ return { available: true };
+ });
+ let clock: ReturnType<typeof vi.spyOn> | undefined;
+ let recovery: ReturnType<typeof f.service.recoverModelCredentials> | undefined;
+ let billing: Promise<unknown> | undefined;
+ try {
+ recovery = f.service.recoverModelCredentials('1');
+ await expect.poll(() => f.client.bootstrap.mock.calls.length).toBe(1);
+ clock = vi.spyOn(Date, 'now').mockReturnValue(Date.now() + 16 * 60_000);
+ billing = f.service.billing('/api/v1/billing/summary').then(value => ({ value }), error => ({ error }));
+ await expect.poll(() => f.client.refresh.mock.calls.length).toBe(1);
+ if (order === 'binding-first') { resumeBinding(); await recovery; resumeRefresh(); }
+ else { resumeRefresh(); await billing; resumeBinding(); }
+ await recovery;
+ expect(await billing).toEqual({ value: { available: true } });
+ expect(request).toHaveBeenCalledExactlyOnceWith('/api/v1/billing/summary', 'new-access', undefined);
+ expect(f.service.peekState()).toMatchObject({ authState: 'signed_in', activationState: 'ready' });
+ expect(await f.service.modelCredentials()).toMatchObject({ modelKey: 'replacement-model-key', keyVersion: '2', bindingVersion: '1:2' });
+ const persisted = await createGatewayConfigStore(f.root).readCredentials();
+ expect(persisted).toMatchObject({ accessToken: 'new-access', refreshToken: 'new-refresh', modelKey: 'replacement-model-key', keyVersion: '2' });
+ expect(persisted?.modelAccessError).toBeUndefined();
+ } finally {
+ resumeBinding(); resumeRefresh();
+ await Promise.allSettled([recovery, billing]);
+ clock?.mockRestore(); await f.service.close();
+ }
+});
+
+it.each(['binding', 'refresh'] as const)('文本模型激活期间的凭据更新不会被旧快照覆盖(%s)', async update => {
+ const f = await setupCachedAccount({
+ models: [
+ { id: 'gateway-text', modality: 'text', capabilities: ['responses'] },
+ { id: 'second-text', modality: 'text', capabilities: ['responses'] },
+ { id: 'first-image', modality: 'image', capabilities: [] }
+ ], defaults: { text: 'gateway-text', image: 'first-image' }
+ });
+ let resume!: () => void;
+ const waiting = new Promise<void>(resolve => { resume = resolve; });
+ f.activate.mockImplementationOnce(async () => { await waiting; });
+ let clock: ReturnType<typeof vi.spyOn> | undefined;
+ let selection: ReturnType<typeof f.service.selectModel> | undefined;
+ try {
+ selection = f.service.selectModel('text', 'second-text');
+ await expect.poll(() => f.activate.mock.calls.length).toBe(2);
+ if (update === 'binding') {
+ f.client.bootstrap.mockResolvedValue({
+ ...f.bootstrap, modelKey: 'replacement-model-key', keyVersion: '2', bindingVersion: '1:2',
+ models: [...f.bootstrap.models.filter(model => model.modality !== 'image'), { id: 'second-image', modality: 'image', capabilities: [] }],
+ defaults: { text: 'gateway-text', image: 'second-image' }
+ });
+ await f.service.recoverModelCredentials('1');
+ } else {
+ clock = vi.spyOn(Date, 'now').mockReturnValue(Date.now() + 16 * 60_000);
+ await f.service.refresh();
+ }
+ resume(); await selection;
+ const credentials = await f.service.modelCredentials();
+ expect(credentials.defaults.text).toBe('second-text');
+ const store = createGatewayConfigStore(f.root);
+ const persisted = await store.readCredentials();
+ expect(persisted?.defaults).toEqual(credentials.defaults);
+ expect(f.service.peekState().selectedModels).toEqual(credentials.defaults);
+ expect((await store.readConfiguration()).selectedModels).toEqual(credentials.defaults);
+ if (update === 'binding') {
+ expect(credentials).toMatchObject({ modelKey: 'replacement-model-key', keyVersion: '2', bindingVersion: '1:2', defaults: { image: 'second-image' } });
+ expect(persisted).toMatchObject({ modelKey: 'replacement-model-key', keyVersion: '2', bindingVersion: '1:2', defaults: { image: 'second-image' } });
+ expect(persisted?.models).toEqual(credentials.models);
+ } else expect(persisted).toMatchObject({ accessToken: 'new-access', refreshToken: 'new-refresh' });
+ } finally {
+ resume(); await Promise.allSettled([selection]);
+ clock?.mockRestore(); await f.service.close();
+ }
+});
+
+it('后台账号同步挂起时仍可并发调用模型,且不会堆积后台请求', async () => {
+ const f = await setupCachedAccount();
+ await f.service.close();
+ vi.useFakeTimers();
+ let resume!: () => void;
+ const waiting = new Promise<void>(resolve => { resume = resolve; });
+ f.client.bootstrap.mockClear().mockImplementation(async () => { await waiting; return f.bootstrap; });
+ const restored = module.createGatewayAccountService({ dataDir: f.root, client: f.client, activateRuntime: async () => undefined, closeRuntime: async () => undefined, hasActiveTasks: () => false });
+ try {
+ await restored.initialize();
+ await vi.advanceTimersByTimeAsync(60_000);
+ expect(f.client.bootstrap).toHaveBeenCalledOnce();
+ const uses = await Promise.all(Array.from({ length: 20 }, () => restored.beginModelUse()));
+ await Promise.all(uses.map(use => use.release()));
+ await vi.advanceTimersByTimeAsync(180_000);
+ expect(f.client.bootstrap).toHaveBeenCalledOnce();
+ resume();
+ } finally { resume(); await restored.close(); vi.useRealTimers(); }
+});
+
+it('稳定密钥模式退出后拒绝新调用,迟到的密钥恢复不会重新登录', async () => {
+ const f = await setupCachedAccount();
+ let resume!: () => void;
+ const waiting = new Promise<void>(resolve => { resume = resolve; });
+ f.client.bootstrap.mockClear().mockImplementation(async () => { await waiting; return { ...f.bootstrap, modelKey: 'late-model-key', keyVersion: '2' }; });
+ const recovery = f.service.recoverModelCredentials('1');
+ const rejected = expect(recovery).rejects.toMatchObject({ code: 'auth_required' });
+ try {
+ await expect.poll(() => f.client.bootstrap.mock.calls.length).toBe(1);
+ await f.service.logout(); resume(); await rejected;
+ await expect(f.service.beginModelUse()).rejects.toMatchObject({ code: 'auth_required' });
+ expect(await createGatewayConfigStore(f.root).readCredentials()).toBeUndefined();
+ } finally { resume(); await rejected; await f.service.close(); }
+});
+
+it.each([
+ ['account_disabled', 403], ['payment_review_required', 403], ['auth_required', 401], ['gateway_unavailable', 503]
+] as const)('后台确认 %s 时正确处理缓存,重启也保留已确认的失效状态', async (code, status) => {
+ const f = await setupCachedAccount(); await f.service.close();
+ vi.useFakeTimers({ toFake: ['Date', 'setTimeout', 'clearTimeout', 'setInterval', 'clearInterval'] });
+ f.client.bootstrap.mockClear().mockRejectedValue(new GatewayError(code, status));
+ const close = vi.fn(async () => undefined);
+ const restored = module.createGatewayAccountService({ dataDir: f.root, client: f.client, activateRuntime: async () => undefined, closeRuntime: close, hasActiveTasks: () => false });
+ try {
+ await restored.initialize(); await vi.advanceTimersByTimeAsync(60_000);
+ expect(f.client.bootstrap).toHaveBeenCalledOnce();
+ if (status === 503) {
+ const use = await restored.beginModelUse(); await use.release();
+ expect(restored.peekState().activationState).toBe('ready');
+ expect(close).not.toHaveBeenCalled();
+ } else {
+ await vi.waitFor(async () => expect((await createGatewayConfigStore(f.root).readCredentials())?.modelAccessError).toBe(code));
+ await expect(restored.beginModelUse()).rejects.toMatchObject({ code });
+ expect(close).toHaveBeenCalledOnce();
+ await vi.advanceTimersByTimeAsync(600_000);
+ expect(f.client.bootstrap).toHaveBeenCalledOnce();
+ }
+ } finally { await restored.close(); vi.useRealTimers(); }
+ if (status !== 503) {
+ const activate = vi.fn(async () => undefined);
+ const restarted = module.createGatewayAccountService({ dataDir: f.root, client: f.client, activateRuntime: activate, closeRuntime: async () => undefined, hasActiveTasks: () => false, automaticPolling: false, deferStartupActivation: true });
+ try {
+ await restarted.initialize(); await restarted.startBackgroundRestore();
+ await expect(restarted.beginModelUse()).rejects.toMatchObject({ code });
+ expect(activate).not.toHaveBeenCalled();
+ } finally { await restarted.close(); }
+ }
+});
+
+it.each(['refresh', 'bootstrap'] as const)('异步任务从 %s 确认撤销时不等待自己的 Runtime 关闭', async source => {
+ const f = await setupCachedAccount(); await f.service.close();
+ let finishWorker!: () => void;
+ const worker = new Promise<void>(resolve => { finishWorker = resolve; });
+ const close = vi.fn(async () => { await worker; });
+ const restored = module.createGatewayAccountService({ dataDir: f.root, client: f.client, activateRuntime: async () => undefined, closeRuntime: close, hasActiveTasks: () => false, automaticPolling: false });
+ await restored.initialize();
+ const clock = source === 'refresh' ? vi.spyOn(Date, 'now').mockReturnValue(Date.now() + 16 * 60_000) : undefined;
+ if (source === 'refresh') f.client.refresh.mockRejectedValue(new GatewayError('auth_required', 401));
+ else f.client.bootstrap.mockRejectedValue(new GatewayError('account_disabled', 403));
+ try {
+ await expect(restored.recoverModelCredentials('1')).rejects.toMatchObject({ code: source === 'refresh' ? 'auth_required' : 'account_disabled' });
+ expect(close).toHaveBeenCalledOnce();
+ await expect(restored.beginModelUse()).rejects.toBeInstanceOf(GatewayError);
+ } finally { finishWorker(); clock?.mockRestore(); await restored.close(); }
+});
+
+it.each(['profile', 'catalog', 'billing', 'avatar', 'probe'] as const)('按需 %s 接口确认撤销后立即拒绝本地模型请求', async surface => {
+ const f = await setupCachedAccount();
+ const error = new GatewayError('auth_required', 401);
+ const request = vi.spyOn(f.client, 'request').mockImplementation(async path => {
+ if (surface === 'catalog' && path === '/api/v1/me') return { account: f.bootstrap.account };
+ throw error;
+ });
+ f.client.avatar.mockRejectedValue(error);
+ let clock: ReturnType<typeof vi.spyOn> | undefined;
+ try {
+ if (surface === 'avatar') {
+ const store = createGatewayConfigStore(f.root);
+ await store.writeCredentials({ ...(await store.readCredentials())!, account: { ...f.bootstrap.account, avatarUrl: 'https://example.test/avatar.png' } });
+ await f.service.close();
+ const restored = module.createGatewayAccountService({ dataDir: f.root, client: f.client, activateRuntime: async () => undefined, closeRuntime: async () => undefined, hasActiveTasks: () => false, automaticPolling: false });
+ try {
+ await restored.initialize(); await expect(restored.readAvatar('1')).rejects.toMatchObject({ code: 'auth_required' });
+ await expect(restored.beginModelUse()).rejects.toMatchObject({ code: 'auth_required' });
+ } finally { await restored.close(); }
+ } else {
+ if (surface === 'profile' || surface === 'catalog') {
+ clock = vi.spyOn(Date, 'now').mockReturnValue(Date.now() + 31_000);
+ await f.service.readState();
+ } else if (surface === 'billing') await expect(f.service.billing('/api/v1/billing/summary')).rejects.toMatchObject({ code: 'auth_required' });
+ else await expect(f.service.probeCredentials()).rejects.toMatchObject({ code: 'auth_required' });
+ await expect(f.service.beginModelUse()).rejects.toMatchObject({ code: 'auth_required' });
+ }
+ expect(request.mock.calls.length || f.client.avatar.mock.calls.length).toBeGreaterThan(0);
+ expect((await createGatewayConfigStore(f.root).readCredentials())?.modelAccessError).toBe('auth_required');
+ } finally { clock?.mockRestore(); await f.service.close(); }
+});
+
it('本地账号初始化不联网,恢复期间状态可读且任务不会回退到个人模型', async () => {
const f = await setup(undefined, undefined, undefined, undefined, undefined, true);
const bootstrap = await seedSavedAccount(f);
@@ -395,7 +692,7 @@ it('automatically requests migration on restart and defers it for pending suppli
for (const pending of [true, false]) {
const restored = module.createGatewayAccountService({ dataDir: f.root, client: f.client, activateRuntime: f.activate, closeRuntime: f.close, hasActiveTasks: () => false, hasPendingTasks: () => pending, automaticPolling: false });
expect(await restored.readState()).toMatchObject({ authState: 'signed_in', activationState: 'ready' });
- expect(f.client.bootstrap).toHaveBeenLastCalledWith('access-1', { rotate: !pending });
+ expect(f.client.bootstrap).toHaveBeenLastCalledWith('access-1', { rotate: !pending, modelUsePolicy: 'cached-key-v1' });
await restored.close();
}
});
@@ -551,7 +848,7 @@ it('allows login with active and pending jobs without rotating their supplier ke
expect(response.statusCode).toBe(200);
await f.service.pollAuthorization(response.json().attemptId);
expect(await f.service.readState()).toMatchObject({ source: 'gateway', authState: 'signed_in', activationState: 'ready', account: { id: '1' } });
- expect(f.client.bootstrap).toHaveBeenLastCalledWith('access-1', { rotate: false });
+ expect(f.client.bootstrap).toHaveBeenLastCalledWith('access-1', { rotate: false, modelUsePolicy: 'cached-key-v1' });
expect((await f.service.modelCredentials()).accountId).toBe('1');
} finally { await server.close(); await f.service.close(); }
});
@@ -721,7 +1018,7 @@ it('completes official activation when pending tasks appear during initial autho
const grant = await f.service.startAuthorization(); pending = true;
await f.service.pollAuthorization(grant.attemptId);
expect(await f.service.readState()).toMatchObject({ source: 'gateway', authState: 'signed_in', activationState: 'ready', account: { id: '1' }, activationError: null });
- expect(f.client.bootstrap).toHaveBeenLastCalledWith('access-1', { rotate: false });
+ expect(f.client.bootstrap).toHaveBeenLastCalledWith('access-1', { rotate: false, modelUsePolicy: 'cached-key-v1' });
expect(f.activate).toHaveBeenCalledOnce();
await f.service.close();
});
@@ -732,7 +1029,7 @@ it('restores a signed-in session after restart even when unfinished jobs remain'
const restored = module.createGatewayAccountService({ dataDir: f.root, client: f.client, activateRuntime: f.activate, closeRuntime: f.close, hasActiveTasks: () => true, hasPendingTasks: () => true, automaticPolling: false });
try {
expect(await restored.readState()).toMatchObject({ authState: 'signed_in', activationState: 'ready', account: { id: '1' } });
- expect(f.client.bootstrap).toHaveBeenLastCalledWith('access-1', { rotate: false });
+ expect(f.client.bootstrap).toHaveBeenLastCalledWith('access-1', { rotate: false, modelUsePolicy: 'cached-key-v1' });
} finally { await restored.close(); }
});
diff --git a/apps/daemon/test/unit/gateway-client.test.ts b/apps/daemon/test/unit/gateway-client.test.ts
index c7fb32fe..d22ab7c2 100644
--- a/apps/daemon/test/unit/gateway-client.test.ts
+++ b/apps/daemon/test/unit/gateway-client.test.ts
@@ -1,6 +1,16 @@
import { expect, it, vi } from 'vitest';
import { accountSchema, createGatewayClient } from '../../src/gateway/client.js';
+it('协商稳定密钥策略并拒绝仍会自动轮换的响应', async () => {
+ const value = { schemaVersion: 1, transport: 'openrouter-direct', account: { id: 'a', email: 'a@test', verified: true }, modelKey: 'private', keyVersion: '1', bindingVersion: 'a:1', baseUrl: 'https://openrouter.ai/api/v1', models: [], defaults: {}, modelUsePolicy: 'cached-key-v1', keyRotation: false };
+ const fetcher = vi.fn<typeof fetch>(async () => Response.json(value));
+ const client = createGatewayClient('https://gateway.example', fetcher);
+ expect((await client.bootstrap('device-access', { rotate: false, modelUsePolicy: 'cached-key-v1' })).modelUsePolicy).toBe('cached-key-v1');
+ expect(fetcher.mock.calls[0]?.[0]).toBe('https://gateway.example/api/v1/client/bootstrap?rotate=0&modelUsePolicy=cached-key-v1');
+ value.keyRotation = true;
+ await expect(client.bootstrap('device-access')).rejects.toThrow();
+});
+
it('accepts only the explicit direct transport endpoint for official credentials', async () => {
const value = { schemaVersion: 1, transport: 'openrouter-direct', account: { id: 'a', email: 'a@test', verified: true }, modelKey: 'private', keyVersion: '1', bindingVersion: 'a:1', baseUrl: 'https://openrouter.ai/api/v1', models: [], defaults: {} };
const fetcher = vi.fn(async () => Response.json(value));
diff --git a/apps/daemon/test/unit/gateway-direct-runtime-rotation.test.ts b/apps/daemon/test/unit/gateway-direct-runtime-rotation.test.ts
index dfe50c31..5ad43903 100644
--- a/apps/daemon/test/unit/gateway-direct-runtime-rotation.test.ts
+++ b/apps/daemon/test/unit/gateway-direct-runtime-rotation.test.ts
@@ -1,5 +1,6 @@
import { expect, it, vi } from 'vitest';
import { createDirectRuntime } from '../../src/gateway/direct-runtime.js';
+import { GatewayError } from '../../src/gateway/client.js';
it('uses the current coordinated supplier key for each request in the same Runtime', async () => {
let key = 'first-user-key'; let busy = 0;
@@ -33,3 +34,53 @@ it('does not submit a supplier request when coordination denies admission', asyn
expect(fetcher).not.toHaveBeenCalled();
} finally { await runtime.close(); }
});
+
+it.each(['success', 'rejected', 'unchanged', 'offline'] as const)('Runtime 的认证恢复为 %s 时最多提交两次', async outcome => {
+ const fetcher = vi.fn<typeof fetch>().mockImplementation(async () => fetcher.mock.calls.length === 1 || outcome === 'rejected' ? Response.json({}, { status: 401 }) : Response.json({ output: [] }));
+ const release = vi.fn(async () => undefined);
+ const recover = vi.fn(async () => {
+ if (outcome === 'offline') throw new GatewayError('gateway_unavailable');
+ return { key: outcome === 'unchanged' ? 'old-key' : 'new-key', keyVersion: outcome === 'unchanged' ? '1' : '2' };
+ });
+ const runtime = await createDirectRuntime('old-key', fetcher, async () => ({ key: 'old-key', keyVersion: '1', release }), recover);
+ try {
+ const response = await fetch(`${runtime.baseUrl}/responses`, { method: 'POST', headers: { Authorization: `Bearer ${runtime.token}`, 'Content-Type': 'application/json' }, body: JSON.stringify({ model: 'test/text', input: 'test' }) });
+ expect(response.status).toBe(outcome === 'success' ? 200 : 401); await response.json();
+ expect(recover).toHaveBeenCalledExactlyOnceWith('1');
+ expect(fetcher).toHaveBeenCalledTimes(['success', 'rejected'].includes(outcome) ? 2 : 1);
+ expect(new Headers(fetcher.mock.calls[0]![1]!.headers).get('authorization')).toBe('Bearer old-key');
+ if (fetcher.mock.calls.length === 2) {
+ expect(new Headers(fetcher.mock.calls[1]![1]!.headers).get('authorization')).toBe('Bearer new-key');
+ expect(fetcher.mock.calls[1]![1]!.body).toEqual(fetcher.mock.calls[0]![1]!.body);
+ }
+ await vi.waitFor(() => expect(release).toHaveBeenCalledOnce());
+ } finally { await runtime.close(); }
+});
+
+it.each([402, 403, 503])('Runtime 遇到 %s 时不进行认证恢复', async status => {
+ const fetcher = vi.fn<typeof fetch>().mockImplementation(async () => Response.json({}, { status }));
+ const recover = vi.fn(async () => ({ key: 'new-key', keyVersion: '2' }));
+ const runtime = await createDirectRuntime('old-key', fetcher, async () => ({ key: 'old-key', keyVersion: '1', release: async () => undefined }), recover);
+ try {
+ const response = await fetch(`${runtime.baseUrl}/responses`, { method: 'POST', headers: { Authorization: `Bearer ${runtime.token}`, 'Content-Type': 'application/json' }, body: '{}' });
+ await response.json();
+ expect(fetcher).toHaveBeenCalledOnce(); expect(recover).not.toHaveBeenCalled();
+ } finally { await runtime.close(); }
+});
+
+it('Runtime 关闭期间迟到的认证恢复不会再次提交', async () => {
+ let resume!: () => void;
+ const waiting = new Promise<void>(resolve => { resume = resolve; });
+ let signal: AbortSignal | undefined;
+ const fetcher = vi.fn<typeof fetch>().mockImplementation(async (_url, options) => { signal = options?.signal ?? undefined; return Response.json({}, { status: 401 }); });
+ const recover = vi.fn(async () => { await waiting; return { key: 'new-key', keyVersion: '2' }; });
+ const runtime = await createDirectRuntime('old-key', fetcher, async () => ({ key: 'old-key', keyVersion: '1', release: async () => undefined }), recover);
+ const request = fetch(`${runtime.baseUrl}/responses`, { method: 'POST', headers: { Authorization: `Bearer ${runtime.token}`, 'Content-Type': 'application/json' }, body: '{}' }).catch(() => undefined);
+ try {
+ await vi.waitFor(() => expect(recover).toHaveBeenCalledOnce());
+ const closing = runtime.close();
+ await vi.waitFor(() => expect(signal?.aborted).toBe(true));
+ resume(); await closing; await request;
+ expect(fetcher).toHaveBeenCalledOnce();
+ } finally { resume(); await runtime.close(); await request; }
+});
diff --git a/docs/cached-model-credentials.md b/docs/cached-model-credentials.md
new file mode 100644
index 00000000..babda388
--- /dev/null
+++ b/docs/cached-model-credentials.md
@@ -0,0 +1,48 @@
+# 模型调用与账号网关解耦
+
+## 调用规则
+
+客户端在登录或旧凭据激活时向 bootstrap 请求 `modelUsePolicy=cached-key-v1`。只有服务端明确返回同名策略、`transport=openrouter-direct` 和 `keyRotation=false` 时,客户端才启用本地凭据模式。旧服务端响应不包含策略时,继续使用原有账号协调流程。
+
+启用后,正常文本、图片、视频、语音和转录请求从本地获取凭据快照,直接调用模型供应商。请求开始和结束不再等待账号令牌刷新、bootstrap 或 usage 上报。账号网关不可达、账号令牌在时间上过期,不会单独阻止有效模型密钥的使用。
+
+启动时从本地激活完整凭据。账号续期和绑定同步在后台执行,首次延迟 60 秒,成功后约每 60 秒同步,失败后指数退避并加入随机偏移,基础间隔最多 5 分钟。同一时刻只保留一个后台同步请求。余额、资料、平台探测等账号功能仍按需访问网关。
+
+正在执行的请求保留原凭据快照。认证恢复可以更新密钥,但任务活跃或存在未完成请求时保留模型目录和默认模型;空闲后再应用新目录及 Runtime 模型。
+
+## 失败与恢复
+
+- 上游明确返回 HTTP 401:合并凭据同步;仅在获得不同的新密钥后,使用相同请求内容最多重试一次。
+- 同步失败、密钥未变化或新密钥再次被拒绝:返回认证失败,不继续自动重发。
+- HTTP 402、403、503、网络异常及流开始后的错误:不触发换密钥重发。额度不足仍使用现有错误处理。
+- 已受理、流中断或结果未知的请求:保留原幂等标识、凭据收据和任务账本,继续禁止盲目重提。
+- 账号网关明确确认登录失效、账号停用或付款审核暂停:立即禁止新的本地模型请求,并持久化确认结果,重启也不会恢复该缓存的可用状态。普通网关超时或断网保留有效缓存。
+- 退出或关闭期间的迟到响应:不得激活 Runtime 或写回新的登录状态。后台确认撤销时异步关闭 Runtime,避免异步图片工作线程等待自己结束。
+
+本地缓存不能代替供应商计费和额度检查。服务端充值仍更新同一把密钥的累计额度;账号停用仍必须禁用供应商密钥。撤销单台设备的账号会话由后台同步发现,不能把它描述为离线即时撤销模型密钥。
+
+## 服务端配套
+
+配套改动位于 `open-creator-gateway` 仓库。迁移 `016_cached_key_use.sql` 为账户绑定增加持久化的稳定模式标记。一旦账号协商成功,其他设备和旧客户端的 `rotate=1` 不得自动迁移其模型密钥。已有迁移必须先恢复完成,再返回稳定凭据。
+
+历史管理凭据必须继续保留,以便维护旧密钥的额度和禁用状态;稳定账户不会随着新管理凭据上线而自动迁走。删除仍管理稳定账户的历史凭据,会使充值与账号停用同步失效。
+
+## 上线顺序与验收
+
+1. 先部署网关迁移和新服务端,使用独立迁移账号运行迁移,再验证 `/healthz`。
+2. 确认 bootstrap 能协商稳定模式,同时未协商账户仍兼容旧协议。
+3. 再发布客户端。现有旧模式凭据在下次激活时协商,已有稳定模式凭据可以本地启动。
+4. 用测试账号检查:连续模型调用无同步网关请求;网关断网仍能调用有效密钥;充值不换密钥;不同设备和旧客户端不触发轮换;明确认证失败最多重试一次;未知结果不重复提交。
+
+启用稳定模式后,禁止直接回滚到忽略 `cached_key_use` 的旧网关二进制。需要回滚时应使用仍识别稳定标记并禁止自动迁移的兼容版本;客户端可回滚至旧协议,但不能因此解除账户稳定标记。不要通过恢复旧数据库或删除标记来回滚,以免丢失额度记录并打断正在执行的任务。
+
+本轮完成源码与本地定向验证;生产网关部署及 Desktop 安装包更新需要后续发布,当前安装版不会自动包含这次改动。
+
+## 本地验证记录
+
+- 客户端相关定向测试累计 126 项通过,覆盖缓存调用、并发恢复、退出、撤销、流收据、异步图片、视频和旧协议;一个原有账号 API 用例跳过。
+- Daemon 源码和测试 TypeScript 检查通过,Daemon 及网关二进制构建通过。
+- 网关稳定模式、旧轮换、额度及设备相关定向测试通过,`internal/storage` 迁移测试通过。
+- 开发 Runtime 重新启动后,`http://127.0.0.1:19861/.opencreator/runtime/healthz` 返回 `{"ok":true}`。
+- 扩展验证发现两个既有 Windows 兼容失败:Runtime 原生工具用例发送 Bash 命令但实际执行 PowerShell;网关模型缓存用例要求 Unix 私有文件权限。本轮未修改这些无关测试或功能。
+- Go race 检查未执行:当前 `CGO_ENABLED=0`,且未找到 C 编译器。未执行真实付费模型请求、生产部署或 Desktop 打包验证。
diff --git a/runtime/krillinai/internal/service/translate.go b/runtime/krillinai/internal/service/translate.go
index 432bee7d..94ed98c5 100644
--- a/runtime/krillinai/internal/service/translate.go
+++ b/runtime/krillinai/internal/service/translate.go
@@ -776,7 +776,8 @@ Required JSON format (output ONLY this structure):
invalidResultErr = fmt.Errorf("翻译结果包含无效索引或空文本: %d", trans.Index)
break
}
- translations[trans.Index-1] = strings.TrimSpace(trans.Text)
+ // 空行会被 SRT 解析器当成字幕块边界,统一为单行文本。
+ translations[trans.Index-1] = strings.Join(strings.Fields(trans.Text), " ")
}
if invalidResultErr != nil {
lastErr = invalidResultErr
@@ -791,12 +792,12 @@ Required JSON format (output ONLY this structure):
// translateSingleText 翻译单个文本(用作批量翻译失败时的回退)
func (t *Translator) translateSingleText(text string, originLang, targetLang types.StandardLanguageCode) (string, error) {
- prompt := fmt.Sprintf(types.SplitTextPrompt, types.GetStandardLanguageName(targetLang), text)
-
- translatedText, err := t.translateWithRetry(prompt, text, originLang, targetLang)
+ translations, err := t.batchTranslateTexts([]string{text}, originLang, targetLang)
if err != nil {
return "", fmt.Errorf("单文本翻译失败: %w", err)
}
-
- return translatedText, nil
+ if !t.isTranslationValid(text, translations[0], originLang, targetLang) {
+ return "", fmt.Errorf("单文本翻译质量检查失败")
+ }
+ return translations[0], nil
}
diff --git a/runtime/krillinai/internal/service/translate_test.go b/runtime/krillinai/internal/service/translate_test.go
index 2e29362c..7651aaa4 100644
--- a/runtime/krillinai/internal/service/translate_test.go
+++ b/runtime/krillinai/internal/service/translate_test.go
@@ -159,3 +159,33 @@ func TestBatchTranslateTextsRetriesDuplicateIndex(t *testing.T) {
t.Fatalf("translations = %v, calls = %d, error = %v", translations, completer.calls, err)
}
}
+
+func TestBatchTranslateTextsKeepsSubtitleTextInOneBlock(t *testing.T) {
+ log.InitLogger()
+ completer := &scriptedCompleter{responses: []string{
+ `{"translations":[{"index":1,"text":"第一行\n\n第二行"}]}`,
+ }}
+ translator := &Translator{chatCompleter: completer}
+ translations, err := translator.batchTranslateTexts(
+ []string{"first line and second line"}, types.StandardLanguageCode("en"), types.StandardLanguageCode("zh_cn"),
+ )
+ if err != nil || len(translations) != 1 || translations[0] != "第一行 第二行" {
+ t.Fatalf("translations = %v, error = %v", translations, err)
+ }
+}
+
+func TestTranslateSingleTextRejectsSubtitleMarkupAndUsesStructuredTranslation(t *testing.T) {
+ log.InitLogger()
+ completer := &scriptedCompleter{responses: []string{
+ "1<br>\n[它必须快速、令人满足,]<br>\n[It should be fast, satisfying,]\n\n2<br>\n[而且由您常备的食材制成。]",
+ `{"translations":[{"index":1,"text":"它必须快速、令人满足,而且由您常备的食材制成。"}]}`,
+ }}
+ translator := &Translator{chatCompleter: completer}
+ translation, err := translator.translateSingleText(
+ "It should be fast, satisfying, and made from ingredients you can keep available.",
+ types.StandardLanguageCode("en"), types.StandardLanguageCode("zh_cn"),
+ )
+ if err != nil || translation != "它必须快速、令人满足,而且由您常备的食材制成。" || completer.calls != 2 {
+ t.Fatalf("translation = %q, calls = %d, error = %v", translation, completer.calls, err)
+ }
+}