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(remote-agent): 让托管 Claude 请求命中指定供应商 (#5829)

Lizi37945df7302d
diff --git a/apps/desktop/src/main/maker-ipc/register.ts b/apps/desktop/src/main/maker-ipc/register.ts
index 198cf9e3f6..2a3f2fd4bd 100644
--- a/apps/desktop/src/main/maker-ipc/register.ts
+++ b/apps/desktop/src/main/maker-ipc/register.ts
@@ -51,7 +51,7 @@ import {
setProviderGroupTurnProbe,
} from '../provider-group/runtime.js';
import { countProviderRunningTurns, type ProviderLocalLoadRoute } from '../provider-group/localLoad.js';
-import { remoteAgentHostRunningProviders } from '../remote-agent/host/service.js';
+import { remoteAgentHostRunningProviders, resolveRemoteAgentHostClaudeSessionId } from '../remote-agent/host/service.js';
import {
createProviderGroupService,
PROVIDER_GROUP_SUPERSEDED_ERROR,
@@ -6850,7 +6850,7 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
setClaudeProxySessionIdResolver((sdkSessionId) => {
if (isAppSessionBoundaryPending()) return null;
const s = maker.listActiveSessions().find((x) => x.requestSessionId === sdkSessionId);
- return s ? s.id : null;
+ return s ? s.id : resolveRemoteAgentHostClaudeSessionId(sdkSessionId);
});
// 会话移动转录迁移:活跃会话桥(查内存 sdkSessionId + 关闭 handle)。
diff --git a/apps/desktop/src/main/remote-agent/__tests__/claudeHosted.e2e.test.ts b/apps/desktop/src/main/remote-agent/__tests__/claudeHosted.e2e.test.ts
index fc1f0f9cca..158cf8d5b6 100644
--- a/apps/desktop/src/main/remote-agent/__tests__/claudeHosted.e2e.test.ts
+++ b/apps/desktop/src/main/remote-agent/__tests__/claudeHosted.e2e.test.ts
@@ -10,13 +10,19 @@ import { createServer, type Server } from 'node:http';
import os from 'node:os';
import path from 'node:path';
+import { createAnthropicCompatProxy, type ProxyHandle } from '@cindy/anthropic-compat-proxy';
import { ClaudeCodeAgent, type AgentDeps, type AgentEvent, type InteractionRequest, type Logger } from '@cindy/maker-core';
-import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { buildUserProvider } from '@cindy/model-providers';
+import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest';
import { remoteAgentEventMapper } from '../controller/eventMap';
import { startRemoteAgentSession } from '../controller/startRemote';
import { createRemoteAgentHost } from '../host/runHost';
import { hostedStartOptions } from '../host/service';
+import { getActiveCatalog, setCustomProviders } from '../../maker-host/active-catalog';
+import { createModelRoutingTransform, setClaudeProxyGatewayKeyReader, setClaudeProxySessionIdResolver } from '../../maker-host/anthropic-compat-proxy-host';
+import { setCustomProviderKeyReader } from '../../maker-host/provider-route';
+import { bindHostedSessionProvider, clearAllSessionProviders } from '../../maker-host/session-provider-store';
const REPO = path.resolve(__dirname, '../../../../../..');
const ARCH = `${process.platform}-${process.arch}`;
@@ -57,6 +63,8 @@ function text(value: string): string {
}
interface MainRequest {
+ sdkSessionId: string;
+ apiKey: string;
system: string;
firstUser: string;
toolNames: string[];
@@ -116,7 +124,11 @@ describe.skipIf(!available)('remote agent with a real Claude Code', () => {
if (block.type === 'tool_result') results.push({ text: contentText(block.content), isError: block.is_error === true });
}
}
- requests.push({ system, firstUser, toolNames, results });
+ requests.push({
+ system, firstUser, toolNames, results,
+ sdkSessionId: String(req.headers['x-claude-code-session-id'] ?? ''),
+ apiKey: String(req.headers['x-api-key'] ?? ''),
+ });
const step = steps[results.length];
res.end(step ? toolUse(results.length, step.name, step.input) : text('all done'));
});
@@ -132,7 +144,7 @@ describe.skipIf(!available)('remote agent with a real Claude Code', () => {
fs.rmSync(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 200 });
});
- function claudeDeps(): AgentDeps {
+ function claudeDeps(proxyEndpoint = endpoint): AgentDeps {
return {
auth: {
getState: async () => ({ authenticated: true, identity: 'test', authSource: 'api-key' as const }),
@@ -140,32 +152,45 @@ describe.skipIf(!available)('remote agent with a real Claude Code', () => {
logout: async () => {},
getAuthEnv: async () => ({ ANTHROPIC_API_KEY: 'fake-test-key' }),
},
- runtimeConfig: { endpoint },
+ runtimeConfig: { endpoint: proxyEndpoint },
binaryPath: CLAUDE,
logger: noopLogger,
};
}
- async function run(permissionMode: 'bypassPermissions' | 'default', resolve?: (request: InteractionRequest) => boolean) {
+ async function run(
+ permissionMode: 'bypassPermissions' | 'default',
+ resolve?: (request: InteractionRequest) => boolean,
+ route?: { endpoint: string; model: string; providerId: string; resolveHostedId?: boolean },
+ ) {
const project = path.join(root, `project-${permissionMode}`);
const hostRoot = path.join(root, `host-${permissionMode}`);
fs.mkdirSync(project, { recursive: true });
fs.writeFileSync(path.join(project, 'hello.txt'), 'hello from the controller\n');
fs.writeFileSync(path.join(project, 'CLAUDE.md'), '# Project memory\nAlways answer briefly.\n');
- const agent = new ClaudeCodeAgent(claudeDeps());
+ const agent = new ClaudeCodeAgent(claudeDeps(route?.endpoint));
const host = createRemoteAgentHost({
isAgentAvailable: (kind) => kind === 'claude-code',
startHosted: (input) => agent.startSession(hostedStartOptions(input)),
isControllerAuthorized: () => true,
+ ...(route ? {
+ providerAccess: {
+ resolve: async () => route.providerId,
+ isAllowed: (providerId: string) => providerId === route.providerId,
+ },
+ bindOwnerProviderRoute: bindHostedSessionProvider,
+ } : {}),
captureOwner: () => 'owner',
isOwnerCurrent: () => true,
runsRoot: hostRoot,
});
+ if (route) setClaudeProxySessionIdResolver((sdkSessionId) => route.resolveHostedId === false ? null : host.resolveClaudeSessionId(sdkSessionId));
const captured: string[] = [];
const handle = await startRemoteAgentSession('claude-code', {
sessionId: `cc-hosted-${permissionMode}`,
workingDir: project,
- model: MODEL,
+ model: route?.model ?? MODEL,
+ ...(route ? { providerId: route.providerId } : {}),
permissionMode,
}, {
invoke: async (args) => JSON.parse(JSON.stringify(await host.handle('controller-1', JSON.parse(JSON.stringify(args[0]))) ?? null)),
@@ -200,10 +225,13 @@ describe.skipIf(!available)('remote agent with a real Claude Code', () => {
if (event.type === 'done') return;
}
})();
- await handle.send({ type: 'user', content: 'Do the scripted work.' });
- await done;
- await handle.close({ reason: 'navigation' });
- host.dispose();
+ try {
+ await handle.send({ type: 'user', content: 'Do the scripted work.' });
+ await done;
+ } finally {
+ await handle.close({ reason: 'navigation' });
+ host.dispose();
+ }
return { project, hostRoot, events, asked, captured };
}
@@ -268,4 +296,89 @@ describe.skipIf(!available)('remote agent with a real Claude Code', () => {
expect(last.results[1].isError).toBe(false);
expect(last.results[3].isError).toBe(true);
});
+
+ async function withProviderProxy(
+ model: string,
+ use: (proxyEndpoint: string, fallbackRequests: string[]) => Promise<void>,
+ createProxy = createAnthropicCompatProxy,
+ ): Promise<void> {
+ const fallbackRequests: string[] = [];
+ const fallback = createServer((req, res) => {
+ if (req.method === 'POST' && req.url?.startsWith('/v1/messages')) fallbackRequests.push(req.url);
+ req.resume();
+ res.writeHead(200, { 'content-type': 'text/event-stream' }).end(text('FALLBACK'));
+ });
+ let proxy: ProxyHandle | undefined;
+ try {
+ await new Promise<void>((resolve, reject) => {
+ fallback.once('error', reject);
+ fallback.listen(0, '127.0.0.1', () => {
+ fallback.removeListener('error', reject);
+ resolve();
+ });
+ });
+ const address = fallback.address();
+ if (!address || typeof address === 'string') throw new Error('fallback server has no port');
+ const fallbackEndpoint = `http://127.0.0.1:${address.port}`;
+ setCustomProviders(['selected', 'other'].map((id) => buildUserProvider({
+ id, name: id,
+ runtimes: { 'claude-code': {
+ baseUrl: id === 'selected' ? endpoint : fallbackEndpoint,
+ wireProtocol: 'anthropic-messages', models: [{ id: model, name: model }],
+ } },
+ })));
+ setCustomProviderKeyReader((id) => `${id}-native-test-key`);
+ setClaudeProxyGatewayKeyReader(() => 'fake-test-key');
+ proxy = await createProxy({ upstream: fallbackEndpoint, routingTransform: createModelRoutingTransform() });
+ await use(proxy.url, fallbackRequests);
+ } finally {
+ try {
+ await proxy?.dispose();
+ } finally {
+ try {
+ if (fallback.listening) await new Promise<void>((resolve) => fallback.close(() => resolve()));
+ } finally {
+ setClaudeProxySessionIdResolver(() => null);
+ setClaudeProxyGatewayKeyReader(() => null);
+ setCustomProviderKeyReader(() => null);
+ setCustomProviders([]);
+ clearAllSessionProviders();
+ }
+ }
+ }
+ }
+
+ it('cleans up the fallback server and provider settings when proxy startup fails', async () => {
+ let fallbackEndpoint = '';
+ const use = vi.fn(async () => {});
+ const createProxy = vi.fn<typeof createAnthropicCompatProxy>(async (options) => {
+ if (typeof options.upstream !== 'string') throw new Error('expected a literal test upstream');
+ fallbackEndpoint = options.upstream;
+ throw new Error('proxy startup failed');
+ });
+ await expect(withProviderProxy('hosted-shared-model', use, createProxy)).rejects.toThrow('proxy startup failed');
+ expect(createProxy).toHaveBeenCalledOnce();
+ expect(use).not.toHaveBeenCalled();
+ expect(getActiveCatalog().providers.some((provider) => provider.id === 'selected' || provider.id === 'other')).toBe(false);
+ await expect(fetch(fallbackEndpoint)).rejects.toThrow();
+ });
+
+ it.each(['claude-sonnet-4-5-20250929', 'hosted-shared-model'])('routes the first real Claude SDK model request for %s to its selected provider', { timeout: 120_000 }, async (model) => {
+ await withProviderProxy(model, async (proxyEndpoint, fallbackRequests) => {
+ requests.length = 0;
+ steps = [];
+ if (model.startsWith('claude-')) {
+ await run('bypassPermissions', undefined, { endpoint: proxyEndpoint, model, providerId: 'selected', resolveHostedId: false });
+ expect(fallbackRequests.length).toBeGreaterThan(0);
+ expect(requests).toEqual([]);
+ fallbackRequests.length = 0;
+ }
+ await run('bypassPermissions', undefined, { endpoint: proxyEndpoint, model, providerId: 'selected' });
+ expect(requests.length).toBeGreaterThan(0);
+ expect(requests[0].sdkSessionId).toMatch(/^[0-9a-f-]{36}$/);
+ expect(requests[0].sdkSessionId).not.toBe('cc-hosted-bypassPermissions');
+ expect(requests.every((request) => request.apiKey === 'selected-native-test-key')).toBe(true);
+ expect(fallbackRequests).toEqual([]);
+ });
+ });
});
diff --git a/apps/desktop/src/main/remote-agent/__tests__/hostedProviderRouting.test.ts b/apps/desktop/src/main/remote-agent/__tests__/hostedProviderRouting.test.ts
index 92d74e928a..84b472a00d 100644
--- a/apps/desktop/src/main/remote-agent/__tests__/hostedProviderRouting.test.ts
+++ b/apps/desktop/src/main/remote-agent/__tests__/hostedProviderRouting.test.ts
@@ -9,13 +9,21 @@ import { buildUserProvider } from '@cindy/model-providers';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
vi.mock('../../appCapabilities.js', () => ({ getAppCapabilities: () => ({ canUseCindyGateway: true }) }));
+vi.mock('../../maker-host/runtime-configs', () => ({ claudeUpstreamEndpoint: () => 'https://gateway.example.invalid' }));
+vi.mock('../../maker-host/silent-encrypted-retry-store', () => ({ readSilentEncryptedRetrySettings: () => ({ enabled: false }) }));
+vi.mock('../../maker-host/claude-fast-mode-log', () => ({
+ createClaudeFastModeRequestTransform: () => () => null,
+ createClaudeFastModeResponseObserver: () => () => undefined,
+}));
import { setCustomProviders } from '../../maker-host/active-catalog';
+import { createModelRoutingTransform, setClaudeProxyGatewayKeyReader, setClaudeProxySessionIdResolver } from '../../maker-host/anthropic-compat-proxy-host';
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 CLAUDE_MODEL = 'claude-sonnet-4-5-20250929';
const OWNER = 'controller-1';
let root: string;
let host: ReturnType<typeof createRemoteAgentHost>;
@@ -36,9 +44,14 @@ beforeEach(() => {
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 }] } },
+ runtimes: {
+ codex: { baseUrl: 'https://' + id + '.example.invalid/v1', wireProtocol: 'openai-responses', models: [{ id: MODEL, name: MODEL }] },
+ 'claude-code': { baseUrl: 'https://' + id + '.example.invalid/anthropic', wireProtocol: 'anthropic-messages', models: [MODEL, CLAUDE_MODEL].map((model) => ({ id: model, name: model })) },
+ },
})));
setCustomProviderKeyReader((id) => 'test-key-' + id);
+ setClaudeProxyGatewayKeyReader(() => 'test-gateway-key');
+ setClaudeProxySessionIdResolver((sdkSessionId) => host.resolveClaudeSessionId(sdkSessionId));
});
afterEach(async () => {
@@ -50,12 +63,19 @@ afterEach(async () => {
for (const dir of shadowRoots) expect(fs.existsSync(dir)).toBe(false);
});
clearAllSessionProviders();
+ setClaudeProxySessionIdResolver(() => null);
+ setClaudeProxyGatewayKeyReader(() => null);
setCustomProviders([]);
setCustomProviderKeyReader(() => null);
fs.rmSync(root, { recursive: true, force: true });
});
-function setup(hooks: { start?: (input: HostedStartInput) => Promise<void> } = {}) {
+function setup(hooks: {
+ start?: (input: HostedStartInput) => Promise<void>;
+ requestSessionId?: (input: HostedStartInput) => string;
+ isOwnerCurrent?: () => boolean;
+ trust?: 'owner' | 'guest';
+} = {}) {
const starts: HostedStartInput[] = [];
const routes: unknown[] = [];
const switches = vi.fn(async (_input: HostedStartInput) => {});
@@ -63,11 +83,13 @@ function setup(hooks: { start?: (input: HostedStartInput) => Promise<void> } = {
host = createRemoteAgentHost({
isAgentAvailable: () => true,
isControllerAuthorized: () => true,
+ controllerTrust: () => hooks.trust ?? 'owner',
providerAccess: {
resolve: async (_kind, _model, providerId) => providerId === 'forbidden' ? null : providerId ?? 'fp',
isAllowed: (providerId) => providerId !== 'forbidden',
},
bindOwnerProviderRoute: bindHostedSessionProvider,
+ bindGuestProviderRoute: async () => ({ routeToken: 'test-guest-route', modelIds: [MODEL], release() {} }),
startHosted: async (input) => {
starts.push(input);
shadowRoots.add(path.dirname(input.mirrorRoot));
@@ -76,7 +98,8 @@ function setup(hooks: { start?: (input: HostedStartInput) => Promise<void> } = {
await hooks.start?.(input);
const end = deferred();
return {
- id: 'sdk-' + input.hostSessionId, agentKind: 'codex', model: MODEL,
+ id: 'sdk-' + input.hostSessionId, agentKind: input.kind, model: MODEL,
+ get requestSessionId() { return hooks.requestSessionId?.(input) ?? 'sdk-' + input.hostSessionId; },
async send() {}, async steer() {}, async abort() {},
async close() { closed(); end.resolve(); },
async setModel() { await switches(input); },
@@ -85,16 +108,17 @@ function setup(hooks: { start?: (input: HostedStartInput) => Promise<void> } = {
setInteractionResolver() {},
} satisfies AgentSessionHandle;
},
- captureOwner: () => 'owner', isOwnerCurrent: () => true, runsRoot: path.join(root, 'host'),
+ captureOwner: () => 'owner', isOwnerCurrent: hooks.isOwnerCurrent ?? (() => true), runsRoot: path.join(root, 'host'),
});
return { starts, routes, switches, closed };
}
-async function open(providerId: string | null = 'fp', sessionId = 'task-1', controller = OWNER) {
+async function open(providerId: string | null = 'fp', sessionId = 'task-1', controller = OWNER, kind: HostedStartInput['kind'] = 'codex', virtualWorkspace = false) {
const runId = randomUUID();
await host.handle(controller, {
- op: 'open', runId, agentKind: 'codex', payload: { json: {
+ op: 'open', runId, agentKind: kind, payload: { json: {
sessionId, options: { model: MODEL, providerId },
+ ...(virtualWorkspace ? { virtualWorkspace: true } : {}),
// 控制端的逻辑 POSIX 路径,与测试宿主平台无关。
workspace: { workingDir: '/Users/owner/proj', platform: 'darwin', shell: 'zsh' },
projectFiles: [], ancestorFiles: [], personal: { files: [] }, mcpServers: [],
@@ -124,6 +148,91 @@ async function switchProvider(runId: string, providerId?: string | null) {
}
describe('same-account hosted provider routing', () => {
+ it.each([CLAUDE_MODEL, MODEL])('routes Claude SDK-ID requests to the selected provider for %s', async (model) => {
+ const sdkSessionId = randomUUID();
+ setup({ requestSessionId: () => sdkSessionId });
+ const runId = await open('fp', 'task-1', OWNER, 'claude-code');
+ await waitForEvent(runId, 'started');
+ const decision = await createModelRoutingTransform()({ model }, {
+ reqId: 1, method: 'POST', url: '/v1/messages',
+ headers: { 'x-claude-code-session-id': sdkSessionId, 'x-api-key': 'test-gateway-key' },
+ });
+ expect(decision).toMatchObject({
+ upstreamOverride: 'https://fp.example.invalid/anthropic',
+ headerOverride: { 'x-api-key': 'test-key-fp' },
+ });
+ expect(host.resolveClaudeSessionId(sdkSessionId)).toBe(hostSessionIdFor(OWNER, 'task-1'));
+ await host.handle(OWNER, { op: 'close', runId, mode: 'close', reason: 'navigation' });
+ expect(host.resolveClaudeSessionId(sdkSessionId)).toBeNull();
+ });
+
+ it('follows the live Claude request ID instead of the durable transcript ID', async () => {
+ let sdkSessionId: string = randomUUID();
+ let ownerCurrent = true;
+ setup({ requestSessionId: () => sdkSessionId, isOwnerCurrent: () => ownerCurrent });
+ const runId = await open('fp', 'task-1', OWNER, 'claude-code');
+ await waitForEvent(runId, 'started');
+ const previousId = sdkSessionId;
+ expect(host.resolveClaudeSessionId(randomUUID())).toBeNull();
+ sdkSessionId = '<pending>';
+ expect(host.resolveClaudeSessionId(sdkSessionId)).toBeNull();
+ sdkSessionId = randomUUID();
+ expect(host.resolveClaudeSessionId(previousId)).toBeNull();
+ expect(host.resolveClaudeSessionId('sdk-' + hostSessionIdFor(OWNER, 'task-1'))).toBeNull();
+ expect(host.resolveClaudeSessionId(sdkSessionId)).toBe(hostSessionIdFor(OWNER, 'task-1'));
+ ownerCurrent = false;
+ expect(host.resolveClaudeSessionId(sdkSessionId)).toBeNull();
+ ownerCurrent = true;
+ host.dispose();
+ expect(host.resolveClaudeSessionId(sdkSessionId)).toBeNull();
+ });
+
+ it.each(['codex', 'pi'] as const)('does not resolve %s handles as Claude sessions', async (kind) => {
+ const sdkSessionId = randomUUID();
+ setup({ requestSessionId: () => sdkSessionId });
+ const runId = await open('fp', 'task-1', OWNER, kind);
+ await waitForEvent(runId, 'started');
+ expect(host.resolveClaudeSessionId(sdkSessionId)).toBeNull();
+ });
+
+ it('removes a controller identity when its running task is revoked', async () => {
+ const sdkSessionId = randomUUID();
+ setup({ requestSessionId: () => sdkSessionId });
+ const runId = await open('fp', 'task-1', OWNER, 'claude-code');
+ await waitForEvent(runId, 'started');
+ expect(host.resolveClaudeSessionId(sdkSessionId)).toBe(hostSessionIdFor(OWNER, 'task-1'));
+ await host.abortControllers((controller) => controller === OWNER);
+ expect(host.resolveClaudeSessionId(sdkSessionId)).toBeNull();
+ });
+
+ it('does not expose guest request IDs through the owner resolver', async () => {
+ const sdkSessionId = randomUUID();
+ setup({ requestSessionId: () => sdkSessionId, trust: 'guest' });
+ const runId = await open('fp', 'task-1', OWNER, 'claude-code', true);
+ await waitForEvent(runId, 'started');
+ expect(host.resolveClaudeSessionId(sdkSessionId)).toBeNull();
+ expect(host.resolveClaudeSessionId('<pending>')).toBeNull();
+ });
+
+ it('drops a superseded Claude handle without losing another controller identity', async () => {
+ const ids = new Map<HostedStartInput, string>();
+ const { starts } = setup({
+ start: async (input) => { ids.set(input, randomUUID()); },
+ requestSessionId: (input) => ids.get(input)!,
+ });
+ const first = await open('fp', 'task-1', OWNER, 'claude-code');
+ await waitForEvent(first, 'started');
+ const firstId = ids.get(starts[0])!;
+ const peer = await open('other', 'task-1', 'controller-2', 'claude-code');
+ await waitForEvent(peer, 'started', undefined, 'controller-2');
+ const peerId = ids.get(starts[1])!;
+ const replacement = await open('other', 'task-1', OWNER, 'claude-code');
+ await waitForEvent(replacement, 'started');
+ expect(host.resolveClaudeSessionId(firstId)).toBeNull();
+ expect(host.resolveClaudeSessionId(ids.get(starts[2])!)).toBe(hostSessionIdFor(OWNER, 'task-1'));
+ expect(host.resolveClaudeSessionId(peerId)).toBe(hostSessionIdFor('controller-2', 'task-1'));
+ });
+
it.each(['fp', null])('routes the first request to the authorized custom provider (%s)', async (providerId) => {
const { routes } = setup();
const runId = await open(providerId);
diff --git a/apps/desktop/src/main/remote-agent/host/runHost.ts b/apps/desktop/src/main/remote-agent/host/runHost.ts
index 1fb9cb6e20..57d6909f86 100644
--- a/apps/desktop/src/main/remote-agent/host/runHost.ts
+++ b/apps/desktop/src/main/remote-agent/host/runHost.ts
@@ -2244,6 +2244,22 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
return {
handle,
+ resolveClaudeSessionId(sdkSessionId: string): string | null {
+ if (disposed || !sdkSessionId || sdkSessionId === '<pending>') return null;
+ for (const run of runs.values()) {
+ if (
+ run.kind !== 'claude-code'
+ || run.trust !== 'owner'
+ || run.closing
+ || run.closedAt !== undefined
+ || run.relay
+ || run.handle?.requestSessionId !== sdkSessionId
+ ) continue;
+ if (!deps.isOwnerCurrent(run.owner)) return null;
+ return run.hostSessionId ?? null;
+ }
+ return null;
+ },
/** 远程控制关闭 / 退出时结束全部任务。 */
async abortAll(reason: RemoteAgentTeardownReason = 'navigation'): Promise<void> {
await Promise.all([...runs.values()].map((run) => finishRun(run, 'aborted', reason)));
diff --git a/apps/desktop/src/main/remote-agent/host/service.ts b/apps/desktop/src/main/remote-agent/host/service.ts
index e2cdf8df94..66b957d478 100644
--- a/apps/desktop/src/main/remote-agent/host/service.ts
+++ b/apps/desktop/src/main/remote-agent/host/service.ts
@@ -194,6 +194,10 @@ export function remoteAgentHostRunningProviders(): string[] {
return host?.turnRunningProviders() ?? [];
}
+export function resolveRemoteAgentHostClaudeSessionId(sdkSessionId: string): string | null {
+ return host?.resolveClaudeSessionId(sdkSessionId) ?? null;
+}
+
/** 退出时结束全部远程 Agent 任务。 */
export function disposeRemoteAgentHost(): void {
setRemoteAgentHandler(null);