Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

fix(desktop): register hosted remote provider routes (#5808)

Lizi3a9f160a9daa
diff --git a/apps/desktop/src/main/maker-host/__tests__/sessionProviderStore.test.ts b/apps/desktop/src/main/maker-host/__tests__/sessionProviderStore.test.ts
index f509051ad1..edcb8eb523 100644
--- a/apps/desktop/src/main/maker-host/__tests__/sessionProviderStore.test.ts
+++ b/apps/desktop/src/main/maker-host/__tests__/sessionProviderStore.test.ts
@@ -10,13 +10,42 @@ import { resolve } from 'node:path';
import { beforeEach, describe, expect, it } from 'vitest';
import {
+ bindHostedSessionProvider,
clearAllSessionProviders,
+ clearSessionProvider,
freezeSessionProviderAtStart,
getSessionProvider,
hasSessionProvider,
setSessionProvider,
} from '../session-provider-store';
+describe('hosted provider binding lifecycle', () => {
+ beforeEach(() => clearAllSessionProviders());
+
+ it('keeps a replacement run registered despite late updates and cleanup from the old run', () => {
+ const old = bindHostedSessionProvider('remote-task', 'fp');
+ const current = bindHostedSessionProvider('remote-task', 'other');
+ old.setProvider('stale');
+ old.release();
+ expect(getSessionProvider('remote-task')).toBe('other');
+ current.setProvider('fp');
+ expect(getSessionProvider('remote-task')).toBe('fp');
+ current.release();
+ expect(hasSessionProvider('remote-task')).toBe(false);
+ });
+
+ it.each(['session', 'account', 'overwrite'] as const)('invalidates late callbacks on %s cleanup', (boundary) => {
+ const binding = bindHostedSessionProvider('remote-task', 'fp');
+ if (boundary === 'session') clearSessionProvider('remote-task');
+ if (boundary === 'account') clearAllSessionProviders();
+ if (boundary === 'overwrite') setSessionProvider('remote-task', 'new-source');
+ binding.setProvider('late');
+ binding.release();
+ expect(getSessionProvider('remote-task')).toBe(boundary === 'overwrite' ? 'new-source' : null);
+ expect(hasSessionProvider('remote-task')).toBe(boundary === 'overwrite');
+ });
+});
+
describe('freezeSessionProviderAtStart', () => {
beforeEach(() => {
clearAllSessionProviders();
diff --git a/apps/desktop/src/main/maker-host/session-provider-store.ts b/apps/desktop/src/main/maker-host/session-provider-store.ts
index eedbe6ebf7..d1dee7667c 100644
--- a/apps/desktop/src/main/maker-host/session-provider-store.ts
+++ b/apps/desktop/src/main/maker-host/session-provider-store.ts
@@ -15,6 +15,7 @@
*/
const bySession = new Map<string, string | null>();
+const hostedBindings = new Map<string, symbol>();
/** Canonical provider id used by runtime routing and every persistence adapter. */
export function normalizeSessionProviderId(
@@ -27,9 +28,34 @@ export function normalizeSessionProviderId(
/** 设定某会话的供应商(SET_MODEL 携带 providerId 时调用)。null/'' = 清除显式选择。 */
export function setSessionProvider(sessionId: string, providerId: string | null): void {
+ hostedBindings.delete(sessionId);
bySession.set(sessionId, normalizeSessionProviderId(providerId) ?? null);
}
+/**
+ * 托管任务不创建本机 Session,也不经过 prepareStartOptions,须在启动 Agent 前登记来源。
+ * 每次运行持有独立登记:重连后的新运行、普通写入或账号清理都会令旧登记失效,
+ * 迟到的换源/回滚/收尾不能覆盖新运行或重新写回已清掉的来源。
+ */
+export function bindHostedSessionProvider(sessionId: string, providerId: string): {
+ setProvider(providerId: string): void;
+ release(): void;
+} {
+ const binding = Symbol();
+ hostedBindings.set(sessionId, binding);
+ bySession.set(sessionId, normalizeSessionProviderId(providerId) ?? null);
+ return {
+ setProvider(nextProviderId) {
+ if (hostedBindings.get(sessionId) !== binding) return;
+ bySession.set(sessionId, normalizeSessionProviderId(nextProviderId) ?? null);
+ },
+ release() {
+ if (hostedBindings.get(sessionId) !== binding) return;
+ clearSessionProvider(sessionId);
+ },
+ };
+}
+
/**
* 启动派发边界(`prepareStartOptions` 钩子)冻结调用方携带的来源:登记须早于第一次
* send 且不经 DB 往返 —— renderer 那份排在 createSession 之后、落库失败只记日志,
@@ -66,10 +92,12 @@ export function hydrateSessionProvider(sessionId: string, providerId: string | n
/** 会话关闭/销毁时清理内存条目。 */
export function clearSessionProvider(sessionId: string): void {
+ hostedBindings.delete(sessionId);
bySession.delete(sessionId);
}
/** 账户 / app-session 边界清理全部 owner-scoped 路由。 */
export function clearAllSessionProviders(): void {
+ hostedBindings.clear();
bySession.clear();
}
diff --git a/apps/desktop/src/main/remote-agent/__tests__/hostedProviderRouting.test.ts b/apps/desktop/src/main/remote-agent/__tests__/hostedProviderRouting.test.ts
new file mode 100644
index 0000000000..92d74e928a
--- /dev/null
+++ b/apps/desktop/src/main/remote-agent/__tests__/hostedProviderRouting.test.ts
@@ -0,0 +1,215 @@
+/** 同账号托管任务的来源必须在首个请求前进入 proxy 的查询路径,且随运行实例收尾。 */
+import { randomUUID } from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import type { AgentEvent, AgentSessionHandle } from '@cindy/maker-core';
+import { buildUserProvider } from '@cindy/model-providers';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+vi.mock('../../appCapabilities.js', () => ({ getAppCapabilities: () => ({ canUseCindyGateway: true }) }));
+
+import { setCustomProviders } from '../../maker-host/active-catalog';
+import { resolveSessionRouteDecision, setCustomProviderKeyReader } from '../../maker-host/provider-route';
+import { bindHostedSessionProvider, clearAllSessionProviders, getSessionProvider, hasSessionProvider } from '../../maker-host/session-provider-store';
+import { createRemoteAgentHost, hostSessionIdFor, type HostedStartInput } from '../host/runHost';
+
+const MODEL = 'gpt-6-astra';
+const OWNER = 'controller-1';
+let root: string;
+let host: ReturnType<typeof createRemoteAgentHost>;
+let shadowRoots: Set<string>;
+let releaseGates: Array<() => void>;
+
+function deferred() {
+ let resolve!: () => void;
+ const promise = new Promise<void>((done) => { resolve = done; });
+ releaseGates.push(resolve);
+ return { promise, resolve };
+}
+
+beforeEach(() => {
+ root = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'cindy-hosted-route-')));
+ shadowRoots = new Set();
+ releaseGates = [];
+ clearAllSessionProviders();
+ setCustomProviders(['fp', 'other'].map((id) => buildUserProvider({
+ id, name: id,
+ runtimes: { codex: { baseUrl: 'https://' + id + '.example.invalid/v1', wireProtocol: 'openai-responses', models: [{ id: MODEL, name: MODEL }] } },
+ })));
+ setCustomProviderKeyReader((id) => 'test-key-' + id);
+});
+
+afterEach(async () => {
+ for (const release of releaseGates) release();
+ await host?.abortAll();
+ host?.dispose();
+ // dispose 在后台删除工作目录;等它结束,避免与 fixture 清理交错。
+ await vi.waitFor(() => {
+ for (const dir of shadowRoots) expect(fs.existsSync(dir)).toBe(false);
+ });
+ clearAllSessionProviders();
+ setCustomProviders([]);
+ setCustomProviderKeyReader(() => null);
+ fs.rmSync(root, { recursive: true, force: true });
+});
+
+function setup(hooks: { start?: (input: HostedStartInput) => Promise<void> } = {}) {
+ const starts: HostedStartInput[] = [];
+ const routes: unknown[] = [];
+ const switches = vi.fn(async (_input: HostedStartInput) => {});
+ const closed = vi.fn();
+ host = createRemoteAgentHost({
+ isAgentAvailable: () => true,
+ isControllerAuthorized: () => true,
+ providerAccess: {
+ resolve: async (_kind, _model, providerId) => providerId === 'forbidden' ? null : providerId ?? 'fp',
+ isAllowed: (providerId) => providerId !== 'forbidden',
+ },
+ bindOwnerProviderRoute: bindHostedSessionProvider,
+ startHosted: async (input) => {
+ starts.push(input);
+ shadowRoots.add(path.dirname(input.mirrorRoot));
+ // 与 Codex proxy 相同的解析器:核对实际 upstream 与凭证,而不只看传入的 providerId。
+ routes.push(await resolveSessionRouteDecision(input.hostSessionId, 'codex', 'unused-gateway-key', MODEL));
+ await hooks.start?.(input);
+ const end = deferred();
+ return {
+ id: 'sdk-' + input.hostSessionId, agentKind: 'codex', model: MODEL,
+ async send() {}, async steer() {}, async abort() {},
+ async close() { closed(); end.resolve(); },
+ async setModel() { await switches(input); },
+ events: () => ({ async *[Symbol.asyncIterator](): AsyncIterator<AgentEvent> { await end.promise; } }),
+ getUsageSnapshot: () => ({ tokenUsage: 0, contextTokens: 0, contextWindow: 0, costUsd: 0 }),
+ setInteractionResolver() {},
+ } satisfies AgentSessionHandle;
+ },
+ captureOwner: () => 'owner', isOwnerCurrent: () => true, runsRoot: path.join(root, 'host'),
+ });
+ return { starts, routes, switches, closed };
+}
+
+async function open(providerId: string | null = 'fp', sessionId = 'task-1', controller = OWNER) {
+ const runId = randomUUID();
+ await host.handle(controller, {
+ op: 'open', runId, agentKind: 'codex', payload: { json: {
+ sessionId, options: { model: MODEL, providerId },
+ // 控制端的逻辑 POSIX 路径,与测试宿主平台无关。
+ workspace: { workingDir: '/Users/owner/proj', platform: 'darwin', shell: 'zsh' },
+ projectFiles: [], ancestorFiles: [], personal: { files: [] }, mcpServers: [],
+ } },
+ });
+ return runId;
+}
+
+async function events(runId: string, controller = OWNER): Promise<Array<Record<string, unknown>>> {
+ const poll = await host.handle(controller, { op: 'poll', runs: [{ runId, cursor: 0 }], waitMs: 0 }) as { runs: Array<{ data?: string }> };
+ return Buffer.from(poll.runs[0]?.data ?? '', 'base64').toString('utf8').split('\n').filter(Boolean).map((line) => JSON.parse(line));
+}
+
+async function waitForEvent(runId: string, type: string, callId?: string, controller = OWNER) {
+ let found: Record<string, unknown> | undefined;
+ await vi.waitFor(async () => {
+ found = (await events(runId, controller)).find((event) => event.t === type && (!callId || event.callId === callId));
+ expect(found).toBeDefined();
+ });
+ return found!;
+}
+
+async function switchProvider(runId: string, providerId?: string | null) {
+ const callId = randomUUID();
+ await host.handle(OWNER, { op: 'call', runId, callId, method: 'setModel', payload: { json: [MODEL, providerId === undefined ? {} : { providerId }] } });
+ return callId;
+}
+
+describe('same-account hosted provider routing', () => {
+ it.each(['fp', null])('routes the first request to the authorized custom provider (%s)', async (providerId) => {
+ const { routes } = setup();
+ const runId = await open(providerId);
+ await waitForEvent(runId, 'started');
+ expect(routes).toEqual([expect.objectContaining({
+ upstreamOverride: 'https://fp.example.invalid/v1',
+ headerOverride: expect.objectContaining({ authorization: 'Bearer test-key-fp' }),
+ })]);
+ await host.handle(OWNER, { op: 'close', runId, mode: 'close', reason: 'navigation' });
+ expect(hasSessionProvider(hostSessionIdFor(OWNER, 'task-1'))).toBe(false);
+ });
+
+ it('registers source changes before calling the agent, keeps model-only changes, and rolls back failures', async () => {
+ const id = hostSessionIdFor(OWNER, 'task-1');
+ const { switches } = setup();
+ switches.mockImplementation(async () => { expect(getSessionProvider(id)).toBe('other'); });
+ const runId = await open();
+ await waitForEvent(runId, 'started');
+ expect(await waitForEvent(runId, 'result', await switchProvider(runId, 'other'))).toMatchObject({ ok: true });
+ expect(getSessionProvider(id)).toBe('other');
+ expect(await waitForEvent(runId, 'result', await switchProvider(runId))).toMatchObject({ ok: true });
+ expect(getSessionProvider(id)).toBe('other');
+ switches.mockImplementationOnce(async () => {
+ expect(getSessionProvider(id)).toBe('fp');
+ throw new Error('switch failed');
+ });
+ expect(await waitForEvent(runId, 'result', await switchProvider(runId, null))).toMatchObject({ ok: false });
+ expect(getSessionProvider(id)).toBe('other');
+ expect(await waitForEvent(runId, 'result', await switchProvider(runId, 'forbidden'))).toMatchObject({ ok: false });
+ expect(getSessionProvider(id)).toBe('other');
+ expect(switches).toHaveBeenCalledTimes(3);
+ });
+
+ it('serializes source changes so a failed earlier change cannot overwrite the next choice', async () => {
+ const pending = deferred();
+ const { switches } = setup();
+ const runId = await open();
+ await waitForEvent(runId, 'started');
+ switches.mockImplementationOnce(async () => { await pending.promise; throw new Error('switch failed'); });
+ const first = await switchProvider(runId, 'other');
+ await vi.waitFor(() => expect(switches).toHaveBeenCalledTimes(1));
+ const second = await switchProvider(runId, 'fp');
+ expect(getSessionProvider(hostSessionIdFor(OWNER, 'task-1'))).toBe('other');
+ pending.resolve();
+ expect(await waitForEvent(runId, 'result', first)).toMatchObject({ ok: false });
+ expect(await waitForEvent(runId, 'result', second)).toMatchObject({ ok: true });
+ expect(getSessionProvider(hostSessionIdFor(OWNER, 'task-1'))).toBe('fp');
+ });
+
+ it('releases registration on startup failure', async () => {
+ setup({ start: async () => { throw new Error('start failed'); } });
+ const runId = await open();
+ await waitForEvent(runId, 'closed');
+ expect(hasSessionProvider(hostSessionIdFor(OWNER, 'task-1'))).toBe(false);
+ });
+
+ it('does not re-register a cancelled startup when its agent finally returns', async () => {
+ const pending = deferred();
+ const { routes, closed } = setup({ start: () => pending.promise });
+ const runId = await open();
+ await vi.waitFor(() => expect(routes).toHaveLength(1));
+ await host.handle(OWNER, { op: 'close', runId, mode: 'close', reason: 'navigation' });
+ expect(hasSessionProvider(hostSessionIdFor(OWNER, 'task-1'))).toBe(false);
+ pending.resolve();
+ await vi.waitFor(() => expect(closed).toHaveBeenCalledTimes(1));
+ expect(hasSessionProvider(hostSessionIdFor(OWNER, 'task-1'))).toBe(false);
+ });
+
+ it('keeps a reconnected task and another controller registered when an old switch fails late', async () => {
+ const pending = deferred();
+ const { switches } = setup();
+ const first = await open();
+ await waitForEvent(first, 'started');
+ const peer = await open('other', 'task-1', 'controller-2');
+ await waitForEvent(peer, 'started', undefined, 'controller-2');
+ switches.mockImplementationOnce(async () => { await pending.promise; throw new Error('old switch failed'); });
+ await switchProvider(first, 'other');
+ await vi.waitFor(() => expect(switches).toHaveBeenCalledTimes(1));
+ const replacement = await open('other');
+ await waitForEvent(replacement, 'started');
+ pending.resolve();
+ await vi.waitFor(() => expect(switches.mock.settledResults[0]?.type).toBe('rejected'));
+ expect(getSessionProvider(hostSessionIdFor(OWNER, 'task-1'))).toBe('other');
+ expect(getSessionProvider(hostSessionIdFor('controller-2', 'task-1'))).toBe('other');
+ await host.handle(OWNER, { op: 'close', runId: replacement, mode: 'close', reason: 'navigation' });
+ expect(hasSessionProvider(hostSessionIdFor(OWNER, 'task-1'))).toBe(false);
+ expect(getSessionProvider(hostSessionIdFor('controller-2', 'task-1'))).toBe('other');
+ });
+});
diff --git a/apps/desktop/src/main/remote-agent/host/runHost.ts b/apps/desktop/src/main/remote-agent/host/runHost.ts
index ea51d4fc19..1fb9cb6e20 100644
--- a/apps/desktop/src/main/remote-agent/host/runHost.ts
+++ b/apps/desktop/src/main/remote-agent/host/runHost.ts
@@ -154,6 +154,12 @@ export interface GuestProviderRouteBinding {
release(): void;
}
+/** 同账号托管任务的来源登记;仅当前运行能更新或撤销它。 */
+export interface OwnerProviderRouteBinding {
+ setProvider(providerId: string): void;
+ release(): void;
+}
+
export interface RemoteAgentHostDeps {
isAgentAvailable(kind: RemoteAgentKind): boolean;
startHosted(input: HostedStartInput): Promise<AgentSessionHandle>;
@@ -187,6 +193,8 @@ export interface RemoteAgentHostDeps {
resolve(kind: RemoteAgentKind, model: string, providerId: string | null | undefined, controller: string): Promise<string | null>;
isAllowed(providerId: string, controller: string): boolean;
};
+ /** 同账号任务也须在启动前登记已核对开放的来源,不能只把 providerId 传给 Agent。 */
+ bindOwnerProviderRoute?(hostSessionId: string, providerId: string): OwnerProviderRouteBinding;
/**
* 受邀者任务的出站边界(只对 guest 调用;不提供 = 不接受受邀者)。启动前登记任务用的供应商:本机
* proxy 只让这条任务的请求经这个供应商、用它提供的模型。release 在任务结束时调用。
@@ -336,6 +344,9 @@ interface Run {
providerId?: string;
/** 受邀者任务的出站登记,任务结束时撤销。 */
guestRoute?: GuestProviderRouteBinding;
+ ownerRoute?: OwnerProviderRouteBinding;
+ /** 换模型/来源串行,避免失败回滚覆盖后一次选择。 */
+ modelChange?: Promise<void>;
usageMeter?: ReturnType<typeof createGuestUsageMeter>;
lastState?: string;
stateTimer?: ReturnType<typeof setInterval>;
@@ -1013,6 +1024,8 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
return;
}
guestProvider = { providerId: run.providerId, modelIds: [...binding.modelIds], routeToken: binding.routeToken };
+ } else if (run.providerId) {
+ run.ownerRoute = deps.bindOwnerProviderRoute?.(hostSessionId, run.providerId);
}
const handle = await deps.startHosted({
kind: run.kind,
@@ -1106,6 +1119,8 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
run.groupLoad = undefined;
run.guestRoute?.release();
run.guestRoute = undefined;
+ run.ownerRoute?.release();
+ run.ownerRoute = undefined;
await run.tunnel?.close().catch(() => undefined);
run.tunnel = undefined;
// 本机这次尝试里已告诉受邀者打开的连接一并关掉(隧道关闭不会逐个回调);中转的连接编号带尝试前缀,不会撞上。
@@ -1605,6 +1620,8 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
// Agent 已关:撤销受邀者的出站登记,之后这条任务的请求一律被本机 proxy 拒绝。
run.guestRoute?.release();
run.guestRoute = undefined;
+ run.ownerRoute?.release();
+ run.ownerRoute = undefined;
await run.tunnel?.close().catch(() => undefined);
// 收尾事件绕过 closing 判断直接写入。
if (!skipClosedEvent) run.log.append({ t: 'closed', reason });
@@ -1647,9 +1664,18 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
}
async function call(run: Run, callId: string, method: RemoteAgentMethod, payload: RemoteAgentPayload): Promise<void> {
+ if (method !== 'setModel') return callOnHandle(run, callId, method, payload);
+ const change = (run.modelChange ?? Promise.resolve()).then(() => callOnHandle(run, callId, method, payload));
+ run.modelChange = change.catch(() => undefined);
+ await change;
+ }
+
+ async function callOnHandle(run: Run, callId: string, method: RemoteAgentMethod, payload: RemoteAgentPayload): Promise<void> {
if (run.relay?.started) return relayCall(run, run.relay, callId, method, payload);
const handle = run.handle;
+ let rollbackProvider: (() => void) | undefined;
try {
+ if (run.closing) fail('REMOTE_AGENT_EXPIRED', 'task has ended');
if (!handle) fail('REMOTE_AGENT_UNAVAILABLE', 'agent has not started');
const raw = await resolvePayload(run.controller, payload);
const args = takeGroupNewRound(run, method, Array.isArray(raw) ? raw : []);
@@ -1710,8 +1736,21 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
});
callArgs = [message, opts];
}
- const value = await (target as (...a: unknown[]) => unknown).apply(handle, callArgs);
- if (nextProviderId) run.providerId = nextProviderId;
+ if (run.closing) fail('REMOTE_AGENT_EXPIRED', 'task has ended');
+ if (nextProviderId && run.ownerRoute && run.providerId) {
+ const binding = run.ownerRoute;
+ const previousProviderId = run.providerId;
+ binding.setProvider(nextProviderId);
+ rollbackProvider = () => binding.setProvider(previousProviderId);
+ }
+ let value: unknown;
+ try {
+ value = await (target as (...a: unknown[]) => unknown).apply(handle, callArgs);
+ } catch (error) {
+ rollbackProvider?.();
+ throw error;
+ }
+ if (nextProviderId && !run.closing) run.providerId = nextProviderId;
append(run, { t: 'result', callId, ok: true, ...(value !== undefined ? { value: JSON.parse(JSON.stringify(value)) } : {}) });
} catch (error) {
append(run, { t: 'result', callId, ok: false, error: remoteAgentErrorInfo(error) });
diff --git a/apps/desktop/src/main/remote-agent/host/service.ts b/apps/desktop/src/main/remote-agent/host/service.ts
index a4ea573148..e2cdf8df94 100644
--- a/apps/desktop/src/main/remote-agent/host/service.ts
+++ b/apps/desktop/src/main/remote-agent/host/service.ts
@@ -27,6 +27,7 @@ import { readDeviceLinkSettings } from '../../device-link/settings-store.js';
import { readTurnUsageResetAt } from '../../goal-host/usageLimit.js';
import { getDesktopProviderService } from '../../maker-host/createDesktopProviderService.js';
import { registerGuestProviderRoute } from '../../maker-host/guest-provider-route-store.js';
+import { bindHostedSessionProvider } from '../../maker-host/session-provider-store.js';
import { isRemoteProviderInvocationAllowed } from '../../maker-host/remote-provider-access-store.js';
import { guestProviderModelIds, resolveGuestProviderId, resolveSharedProviderId } from './providerAccess';
import { createRemoteAgentHost, type HostedStartInput, type RemoteAgentHost, type RunUsageRecord } from './runHost';
@@ -106,6 +107,7 @@ export function installRemoteAgentHost(options: { getMaker: () => Maker; userDat
}
},
startHosted: (input) => options.getMaker().startHostedAgentSession(input.kind, hostedStartOptions(input)),
+ bindOwnerProviderRoute: bindHostedSessionProvider,
isControllerAuthorized: (controller) => {
if (isProviderSharePeer(controller)) return providerShareGuestAccess(controller) !== null;
const settings = readDeviceLinkSettings();