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(claude): keep custom Grok requests on their selected provider (#5307)

Praise7dfd589f1448
diff --git a/apps/desktop/src/main/cindy-brain/__tests__/libraryExtraDirGrantContract.test.ts b/apps/desktop/src/main/cindy-brain/__tests__/libraryExtraDirGrantContract.test.ts
index 94c787265a..f400820de5 100644
--- a/apps/desktop/src/main/cindy-brain/__tests__/libraryExtraDirGrantContract.test.ts
+++ b/apps/desktop/src/main/cindy-brain/__tests__/libraryExtraDirGrantContract.test.ts
@@ -65,7 +65,7 @@ describe('library extraDirs harness grant timing', () => {
});
it('Claude rebuilds next send without fresh; Codex refuses old app-server; Pi writes the current-turn permission file', () => {
- expect(claudeSource).toContain('pendingRewindTo = sdkSessionId');
+ expect(claudeSource).toContain('pendingRewindTo = durableSdkSessionId');
expect(claudeSource).toContain('directoryGrantRebuild ? {} : { resumeSessionAt: resumeAt }');
expect(claudeSource).toContain('下一 turn 生效,不用 fresh:true');
expect(claudeSource).not.toMatch(/directoryGrantRebuild[\s\S]{0,80}fresh:\s*true/);
diff --git a/apps/desktop/src/main/maker-host/__tests__/claudeGrokSessionAffinity.integration.test.ts b/apps/desktop/src/main/maker-host/__tests__/claudeGrokSessionAffinity.integration.test.ts
new file mode 100644
index 0000000000..ae93944bab
--- /dev/null
+++ b/apps/desktop/src/main/maker-host/__tests__/claudeGrokSessionAffinity.integration.test.ts
@@ -0,0 +1,175 @@
+/** Real Claude CLI -> production routing -> local Art fixture; no account access. */
+import { promises as fs } from 'node:fs';
+import { createServer } from 'node:http';
+import type { AddressInfo } from 'node:net';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { createAnthropicCompatProxy } from '@cindy/anthropic-compat-proxy';
+import { buildUserProvider } from '@cindy/model-providers';
+import { ClaudeCodeAgent } from '../../../../../../packages/maker-core/src/agents/claude-code/index.js';
+import { Session } from '../../../../../../packages/maker-core/src/session.js';
+import type { Logger } from '../../../../../../packages/maker-core/src/interfaces/logger.js';
+import type { AgentEvent } from '../../../../../../packages/maker-core/src/types/events.js';
+
+const bridge = vi.hoisted(() => ({ get: vi.fn(() => ({ handle: vi.fn() })) }));
+vi.mock('../anthropic-responses-bridge-host.js', () => ({
+ getResponsesBridgeHandler: bridge.get, getPiNativeSubscriptionHandler: vi.fn(),
+}));
+vi.mock('../../appCapabilities.js', () => ({ getAppCapabilities: () => ({ canUseCindyGateway: true }) }));
+vi.mock('../logger-adapter', () => ({
+ createMakerLogger: () => ({ trace() {}, debug() {}, info() {}, warn() {}, error() {}, child() { return this; } }),
+ desktopMakerLogger: { trace() {}, debug() {}, info() {}, warn() {}, error() {}, child() { return this; } },
+}));
+vi.mock('../runtime-configs', () => ({ claudeUpstreamEndpoint: () => 'http://127.0.0.1:1' }));
+vi.mock('../silent-encrypted-retry-store', () => ({ readSilentEncryptedRetrySettings: () => ({ enabled: false }) }));
+vi.mock('../claude-fast-mode-log', () => ({
+ createClaudeFastModeRequestTransform: () => () => null,
+ createClaudeFastModeResponseObserver: () => () => undefined,
+}));
+
+import { setCustomProviders } from '../active-catalog';
+import { setCustomProviderKeyReader } from '../provider-route';
+import { setSessionProvider, clearSessionProvider } from '../session-provider-store';
+import { createModelRoutingTransform, setClaudeProxySessionIdResolver } from '../anthropic-compat-proxy-host';
+
+const binary = process.env.CINDY_TEST_CLAUDE_BINARY;
+const logger: Logger = { trace() {}, debug() {}, info() {}, warn() {}, error() {}, fatal() {}, child: () => logger };
+
+afterEach(() => {
+ setCustomProviders([]);
+ setCustomProviderKeyReader(() => null);
+ setClaudeProxySessionIdResolver(() => null);
+ bridge.get.mockClear();
+});
+
+describe.skipIf(!binary)('native Claude custom Grok session affinity', () => {
+ it('routes concurrent first requests to their selected Art provider before SDK init', async () => {
+ const scratch = await fs.mkdtemp(path.join(os.tmpdir(), 'cindy-cc-affinity-'));
+ const homeSpy = vi.spyOn(os, 'homedir').mockReturnValue(scratch);
+ const received: Array<{ model: string; sid: string; key: string | undefined }> = [];
+ const routed: Array<{ sid: string; sessionId: string | null }> = [];
+ const sessions: Session[] = [];
+ const agents: ClaudeCodeAgent[] = [];
+ const events: AgentEvent[][] = [[], []];
+ const upstream = createServer(async (req, res) => {
+ const chunks: Buffer[] = [];
+ for await (const chunk of req) chunks.push(Buffer.from(chunk));
+ if (!req.url?.startsWith('/v1/messages')) { res.writeHead(200).end('{}'); return; }
+ const body = JSON.parse(Buffer.concat(chunks).toString());
+ if (req.url.includes('count_tokens')) { res.writeHead(200).end('{"input_tokens":1}'); return; }
+ received.push({ model: body.model, sid: String(req.headers['x-claude-code-session-id']), key: req.headers['x-api-key'] as string });
+ const payloads = [
+ { type: 'message_start', message: { id: 'msg_fixture', type: 'message', role: 'assistant', model: body.model, content: [], stop_reason: null, usage: { input_tokens: 1, output_tokens: 0 } } },
+ { type: 'content_block_start', index: 0, content_block: { type: 'text', text: '' } },
+ { type: 'content_block_delta', index: 0, delta: { type: 'text_delta', text: 'art fixture success' } },
+ { type: 'content_block_stop', index: 0 },
+ { type: 'message_delta', delta: { stop_reason: 'end_turn', stop_sequence: null }, usage: { output_tokens: 3 } },
+ { type: 'message_stop' },
+ ];
+ res.writeHead(200, { 'content-type': 'text/event-stream' });
+ res.end(payloads.map(data => `event: ${data.type}\ndata: ${JSON.stringify(data)}\n\n`).join(''));
+ });
+ await new Promise<void>(resolve => upstream.listen(0, '127.0.0.1', resolve));
+ const upstreamUrl = `http://127.0.0.1:${(upstream.address() as AddressInfo).port}`;
+ const transform = createModelRoutingTransform();
+ const proxy = await createAnthropicCompatProxy({
+ upstream: 'http://127.0.0.1:1',
+ routingTransform: (body, ctx) => {
+ if (ctx.url.startsWith('/v1/messages') && !ctx.url.includes('count_tokens')) {
+ const sid = ctx.headers['x-claude-code-session-id'] ?? '';
+ routed.push({ sid, sessionId: sessions.find(s => s.requestSessionId === sid)?.id ?? null });
+ }
+ return transform(body, ctx);
+ },
+ });
+ try {
+ setCustomProviders([buildUserProvider({ id: 'art-cindy', name: 'Fixture Art', runtimes: {
+ 'claude-code': { baseUrl: upstreamUrl, wireProtocol: 'anthropic-messages', models: [{ id: 'grok-4.6', name: 'Grok' }] },
+ } })]);
+ setCustomProviderKeyReader(() => 'fixture-art-key');
+ setClaudeProxySessionIdResolver(sid => sessions.find(s => s.requestSessionId === sid)?.id ?? null);
+ for (let i = 0; i < 2; i++) {
+ const workingDir = path.join(scratch, `work-${i}`);
+ const configDir = path.join(scratch, `config-${i}`);
+ await fs.mkdir(workingDir);
+ await fs.mkdir(configDir);
+ const agent = new ClaudeCodeAgent({
+ binaryPath: binary!, logger,
+ runtimeConfig: { endpoint: proxy.url, behaviorFlags: {
+ CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST: '1', DISABLE_NONESSENTIAL_TRAFFIC: '1',
+ DISABLE_TELEMETRY: '1', DISABLE_ERROR_REPORTING: '1',
+ } },
+ auth: {
+ getState: async () => ({ authenticated: true, authSource: 'api-key' as const }),
+ triggerLogin: async () => ({ authenticated: true }), logout: async () => {},
+ getAuthEnv: async () => ({ ANTHROPIC_API_KEY: 'xdt-provider-auth-placeholder-key', CLAUDE_CONFIG_DIR: configDir, HOME: scratch }),
+ },
+ });
+ const id = `fixture-business-${i}`;
+ agents.push(agent);
+ setSessionProvider(id, 'art-cindy');
+ const handle = await agent.startSession({ sessionId: id, providerId: 'art-cindy', model: 'grok-4.6', workingDir, permissionMode: 'bypassPermissions' });
+ expect(handle.id).not.toBe('<pending>');
+ const session = new Session({ id, agentKind: 'claude-code', workDir: workingDir, handle, capabilities: agent.capabilities, logger, turnStallMs: 0 });
+ sessions.push(session);
+ session.onEvent(event => events[i].push(event));
+ }
+ expect(sessions[0].sdkSessionId).not.toBe(sessions[1].sdkSessionId);
+ await Promise.all(sessions.map(s => s.send({ type: 'user', content: 'Reply with one short line. Do not use tools.' })));
+ await vi.waitFor(() => expect(events.map(e => e.some(v => v.type === 'done'))).toEqual([true, true]), { timeout: 45_000 });
+ expect(events.flat().filter(e => e.type === 'error')).toEqual([]);
+ // CLI may also request titles/summaries on the same route.
+ expect(received.length).toBeGreaterThanOrEqual(2);
+ expect(received.every(r => r.model === 'grok-4.6' && r.key === 'fixture-art-key')).toBe(true);
+ expect([...new Set(received.map(r => r.sid))].sort()).toEqual(sessions.map(s => s.sdkSessionId).sort());
+ expect(routed.every(r => r.sessionId !== null)).toBe(true);
+ expect([...new Set(routed.map(r => r.sessionId))].sort()).toEqual(['fixture-business-0', 'fixture-business-1']);
+ expect(bridge.get).not.toHaveBeenCalled();
+
+ const sourceId = sessions[0].sdkSessionId;
+ const forkHandle = await agents[0].startSession({
+ sessionId: 'fixture-business-fork', providerId: 'art-cindy', model: 'grok-4.6',
+ workingDir: path.join(scratch, 'work-0'), permissionMode: 'bypassPermissions',
+ resumeSessionId: sourceId, vendorOptions: { forkSession: true },
+ });
+ const fork = new Session({ id: 'fixture-business-fork', agentKind: 'claude-code',
+ workDir: path.join(scratch, 'work-0'), handle: forkHandle,
+ capabilities: agents[0].capabilities, logger, turnStallMs: 0 });
+ sessions.push(fork);
+ const forkEvents: AgentEvent[] = [];
+ fork.onEvent(event => forkEvents.push(event));
+ setSessionProvider(fork.id, 'art-cindy');
+ expect(fork.sdkSessionId).toBe(sourceId);
+ expect(fork.requestSessionId).not.toBe(sourceId);
+ const requestId = fork.requestSessionId;
+ // Route a pre-acceptance bridge request without making that id durable.
+ const preAcceptance = await fetch(`${proxy.url}/v1/messages`, {
+ method: 'POST', headers: { 'content-type': 'application/json',
+ 'x-api-key': 'xdt-provider-auth-placeholder-key', 'x-claude-code-session-id': requestId },
+ body: JSON.stringify({ model: 'grok-4.6', max_tokens: 1, stream: true,
+ messages: [{ role: 'user', content: 'pre-acceptance routing fixture' }] }),
+ });
+ await preAcceptance.text();
+ expect(preAcceptance.status).toBe(200);
+ expect(fork.sdkSessionId).toBe(sourceId);
+ expect(forkEvents.filter(e => e.type === 'session_id')).toEqual([]);
+ expect(routed.at(-1)?.sessionId).toBe(fork.id);
+ await fork.send({ type: 'user', content: 'Continue with one short line. Do not use tools.' });
+ await vi.waitFor(() => expect(forkEvents.some(e => e.type === 'done')).toBe(true), { timeout: 45_000 });
+ expect(forkEvents.filter(e => e.type === 'error')).toEqual([]);
+ expect(fork.sdkSessionId).toBe(requestId);
+ expect(forkEvents.filter(e => e.type === 'session_id')).toHaveLength(1);
+ expect(received.filter(r => r.sid === requestId).every(r => r.model === 'grok-4.6' && r.key === 'fixture-art-key')).toBe(true);
+ expect(bridge.get).not.toHaveBeenCalled();
+ } finally {
+ await Promise.all(sessions.map(s => s.close()));
+ for (const session of sessions) clearSessionProvider(session.id);
+ await proxy.dispose();
+ upstream.closeAllConnections();
+ await new Promise<void>(resolve => upstream.close(() => resolve()));
+ homeSpy.mockRestore();
+ await fs.rm(scratch, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+ }
+ }, 60_000);
+});
diff --git a/apps/desktop/src/main/maker-ipc/register.ts b/apps/desktop/src/main/maker-ipc/register.ts
index 60376f3fae..a2d3cf1bda 100644
--- a/apps/desktop/src/main/maker-ipc/register.ts
+++ b/apps/desktop/src/main/maker-ipc/register.ts
@@ -6333,7 +6333,7 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
setClaudeProxyOwnerScopeKeyReader(activeOwnerScopeKey);
setClaudeProxySessionIdResolver((sdkSessionId) => {
if (isAppSessionBoundaryPending()) return null;
- const s = maker.listActiveSessions().find((x) => x.sdkSessionId === sdkSessionId);
+ const s = maker.listActiveSessions().find((x) => x.requestSessionId === sdkSessionId);
return s ? s.id : null;
});
diff --git a/packages/maker-core/src/agents/base-agent.ts b/packages/maker-core/src/agents/base-agent.ts
index 937fc39469..bd6f2961d4 100644
--- a/packages/maker-core/src/agents/base-agent.ts
+++ b/packages/maker-core/src/agents/base-agent.ts
@@ -2206,8 +2206,10 @@ export interface AgentSessionHandle {
/** Canonical physical Skill identities frozen at native runtime startup. */
readonly disabledSkillPaths?: readonly string[];
getCodexContextWindowInfo?(): Promise<CodexContextWindowInfo | null>;
- /** SDK 内部 sessionId,session.started 后会回填 */
+ /** Native session identity safe for resume; may retain an unaccepted fork's source. */
readonly id: string;
+ /** Transient native request identity; hosts must not persist it as a resume id. */
+ readonly requestSessionId?: string;
readonly agentKind: AgentKind;
readonly model: string;
/** Pi-only, per-session runtime command catalog. Undefined for other agents. */
diff --git a/packages/maker-core/src/agents/claude-code/__tests__/extraDirs-rebuild.test.ts b/packages/maker-core/src/agents/claude-code/__tests__/extraDirs-rebuild.test.ts
index ee91fd08a0..808b766d23 100644
--- a/packages/maker-core/src/agents/claude-code/__tests__/extraDirs-rebuild.test.ts
+++ b/packages/maker-core/src/agents/claude-code/__tests__/extraDirs-rebuild.test.ts
@@ -232,7 +232,7 @@ describe('Claude extraDirs mid-session rebuild', () => {
const source = await fs.readFile(new URL('../index.ts', import.meta.url), 'utf8');
- expect(source).toContain('pendingRewindTo = sdkSessionId');
+ expect(source).toContain('pendingRewindTo = durableSdkSessionId');
expect(source).toContain('directoryGrantRebuild ? {} : { resumeSessionAt: resumeAt }');
expect(source).toContain('extraDirsCopyFallbackEnabled = false');
expect(source).toContain('下一 turn 生效,不用 fresh:true');
diff --git a/packages/maker-core/src/agents/claude-code/__tests__/invalid-resume-recovery.test.ts b/packages/maker-core/src/agents/claude-code/__tests__/invalid-resume-recovery.test.ts
index d84ad96c0d..1db5cb27ff 100644
--- a/packages/maker-core/src/agents/claude-code/__tests__/invalid-resume-recovery.test.ts
+++ b/packages/maker-core/src/agents/claude-code/__tests__/invalid-resume-recovery.test.ts
@@ -147,6 +147,7 @@ async function startHarness(args: {
resumeSessionId?: string;
transcriptExists: boolean;
onInvalidResumeSession: StartSessionOptions['onInvalidResumeSession'];
+ forkSession?: boolean;
}) {
const configDir = await makeTempDir();
const workingDir = await makeTempDir();
@@ -177,7 +178,9 @@ async function startHarness(args: {
return queries[index];
});
- const agent = new ClaudeCodeAgent(createDeps());
+ const deps = createDeps();
+ const debug = vi.spyOn(deps.logger!, 'debug');
+ const agent = new ClaudeCodeAgent(deps);
const handle = await agent.startSession({
sessionId: 'local-session',
model: 'claude-opus-4-6',
@@ -185,6 +188,7 @@ async function startHarness(args: {
permissionMode: 'acceptEdits',
resumeSessionId: args.resumeSessionId,
onInvalidResumeSession: args.onInvalidResumeSession,
+ vendorOptions: args.forkSession ? { forkSession: true } : undefined,
});
const events: AgentEvent[] = [];
const collected = (async () => {
@@ -198,6 +202,7 @@ async function startHarness(args: {
consumedInputs,
events,
collected,
+ debug,
};
}
@@ -215,6 +220,182 @@ afterEach(async () => {
});
describe('Claude invalid-resume recovery', () => {
+ it('binds a new native session before SDK init so its first request can resolve the provider', async () => {
+ const h = await startHarness({ transcriptExists: false, onInvalidResumeSession: undefined });
+ const sessionId = h.queryOptions[0].sessionId;
+ expect(sessionId).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/);
+ expect(h.handle.id).toBe(sessionId);
+ expect(h.queryOptions[0]).not.toHaveProperty('resume');
+ h.streams[0].emit({ type: 'system', subtype: 'init', session_id: sessionId });
+ await vi.waitFor(() => expect(h.events).toContainEqual({
+ type: 'session_id', data: sessionId, source: 'claude-code',
+ }));
+ await h.handle.close();
+ h.streams[0].end();
+ await h.collected;
+ expect(h.events.filter((event) => event.type === 'session_id')).toHaveLength(1);
+ });
+
+ it('keeps the durable source while prebinding an initial fork request', async () => {
+ for (const forkSession of [false, true]) {
+ const h = await startHarness({
+ resumeSessionId: 'sdk-source', transcriptExists: true,
+ onInvalidResumeSession: undefined, forkSession,
+ });
+ expect(h.queryOptions[0].resume).toBe('sdk-source');
+ if (forkSession) {
+ expect(h.queryOptions[0].forkSession).toBe(true);
+ expect(h.queryOptions[0].sessionId).toEqual(expect.any(String));
+ expect(h.handle.id).toBe('sdk-source');
+ expect(h.handle.requestSessionId).toBe(h.queryOptions[0].sessionId);
+ expect(h.handle.requestSessionId).not.toBe('sdk-source');
+ } else {
+ expect(h.queryOptions[0]).not.toHaveProperty('sessionId');
+ expect(h.handle.id).toBe('sdk-source');
+ }
+ await h.handle.close();
+ h.streams[0].end();
+ await h.collected;
+ }
+ });
+
+ it.each(['constructor', 'cancel-after-build', 'conversion', 'cancel-during-conversion', 'cancel-after-init'] as const)(
+ 'retries the source after an unaccepted fork fails at %s', async (failure) => {
+ const clear = vi.fn(async () => true);
+ const h = await startHarness({ resumeSessionId: 'sdk-source', transcriptExists: true, onInvalidResumeSession: clear });
+ await h.handle.commitRewindFiles?.('user-anchor', 'assistant-anchor');
+ const controller = new AbortController();
+ if (failure === 'constructor') {
+ sdkMock.query.mockImplementationOnce(() => { throw new Error('fixture query construction failed'); });
+ } else if (failure === 'cancel-after-build') {
+ const createQuery = sdkMock.query.getMockImplementation()!;
+ sdkMock.query.mockImplementationOnce((...args) => {
+ const result = createQuery(...args);
+ controller.abort();
+ return result;
+ });
+ } else if (failure === 'conversion') {
+ imageResizerMock.process.mockRejectedValueOnce(new Error('fixture conversion failed'));
+ } else {
+ imageResizerMock.process.mockImplementationOnce(async p => {
+ if (failure === 'cancel-after-init') {
+ const destination = sdkMock.query.mock.calls.at(-1)?.[0]?.options?.sessionId;
+ h.streams[1].emit({ type: 'system', subtype: 'init', session_id: destination });
+ await vi.waitFor(() => expect(h.debug).toHaveBeenCalledWith(
+ 'SDK ▶ turn start (system init)', expect.objectContaining({ sdkSessionId: destination }),
+ ));
+ }
+ controller.abort();
+ return p;
+ });
+ }
+ await expect(h.handle.send({
+ type: 'user', content: failure === 'conversion' || failure.startsWith('cancel-during') || failure === 'cancel-after-init'
+ ? [{ type: 'image', path: path.join(os.tmpdir(), 'fixture-fork-image.png') }]
+ : 'cancelled input',
+ }, { signal: controller.signal })).rejects.toThrow(/fixture|cancelled/);
+ expect(h.handle.id).toBe('sdk-source');
+ expect(h.events.filter(e => e.type === 'session_id' && e.data !== 'sdk-source')).toEqual([]);
+ await h.handle.send({ type: 'user', content: 'retry with original context' });
+ const retry = sdkMock.query.mock.calls.at(-1)?.[0]?.options;
+ expect(retry).toMatchObject({ resume: 'sdk-source', resumeSessionAt: 'assistant-anchor', forkSession: true });
+ expect(retry.sessionId).not.toBe('sdk-source');
+ expect(clear).not.toHaveBeenCalled();
+ await h.handle.close();
+ for (const stream of h.streams) stream.end();
+ await h.collected;
+ },
+ );
+
+ it('keeps a directory grant retry as a full-source fork after cancellation', async () => {
+ const clear = vi.fn(async () => true);
+ const h = await startHarness({ resumeSessionId: 'sdk-source', transcriptExists: true, onInvalidResumeSession: clear });
+ await h.handle.setExtraDirs?.([await makeTempDir()]);
+ const controller = new AbortController();
+ const createQuery = sdkMock.query.getMockImplementation()!;
+ sdkMock.query.mockImplementationOnce((...args) => {
+ const result = createQuery(...args);
+ controller.abort();
+ return result;
+ });
+ await expect(h.handle.send({ type: 'user', content: 'cancelled grant' }, { signal: controller.signal })).rejects.toThrow('cancelled');
+ expect(h.handle.id).toBe('sdk-source');
+ await h.handle.send({ type: 'user', content: 'retry grant with context' });
+ const retry = sdkMock.query.mock.calls.at(-1)?.[0]?.options;
+ expect(retry).toMatchObject({ resume: 'sdk-source', forkSession: true });
+ expect(retry).not.toHaveProperty('resumeSessionAt');
+ expect(clear).not.toHaveBeenCalled();
+ await h.handle.close();
+ for (const stream of h.streams) stream.end();
+ await h.collected;
+ });
+
+ it.each([false, true])('does not publish an unaccepted fork before close (initial fork %s)', async (initialFork) => {
+ const h = await startHarness({
+ resumeSessionId: 'sdk-source', transcriptExists: true,
+ onInvalidResumeSession: undefined, forkSession: initialFork,
+ });
+ if (!initialFork) await h.handle.commitRewindFiles?.('user-anchor', 'assistant-anchor');
+ let releaseConversion!: (value: string) => void;
+ imageResizerMock.process.mockImplementationOnce(p => new Promise<string>(resolve => { releaseConversion = resolve; void p; }));
+ const sending = h.handle.send({ type: 'user', content: [{ type: 'image', path: path.join(os.tmpdir(), 'fixture-pending-fork.png') }] });
+ const rejected = expect(sending).rejects.toThrow(/closed|cancelled/);
+ await vi.waitFor(() => expect(releaseConversion).toEqual(expect.any(Function)));
+ const destination = h.handle.requestSessionId;
+ expect(destination).not.toBe('sdk-source');
+ const currentStream = h.streams[initialFork ? 0 : 1];
+ currentStream.emit({ type: 'system', subtype: 'init', session_id: destination });
+ await vi.waitFor(() => expect(h.debug).toHaveBeenCalledWith(
+ 'SDK ▶ turn start (system init)', expect.objectContaining({ sdkSessionId: destination }),
+ ));
+ expect(h.handle.id).toBe('sdk-source');
+ expect(h.events.filter(e => e.type === 'session_id')).toEqual([]);
+ await h.handle.close();
+ releaseConversion(path.join(os.tmpdir(), 'fixture-pending-fork.png'));
+ await rejected;
+ for (const stream of h.streams) stream.end();
+ await h.collected;
+ expect(h.handle.id).toBe('sdk-source');
+ expect(h.events.filter(e => e.type === 'session_id')).toEqual([]);
+ });
+
+ it('commits an initial fork exactly once after accepting input, even if init arrived first', async () => {
+ const h = await startHarness({ resumeSessionId: 'sdk-source', transcriptExists: true, onInvalidResumeSession: undefined, forkSession: true });
+ const destination = h.handle.requestSessionId;
+ h.streams[0].emit({ type: 'system', subtype: 'init', session_id: destination });
+ await vi.waitFor(() => expect(h.debug).toHaveBeenCalledWith(
+ 'SDK ▶ turn start (system init)', expect.objectContaining({ sdkSessionId: destination }),
+ ));
+ expect(h.handle.id).toBe('sdk-source');
+ expect(h.events.filter(e => e.type === 'session_id')).toEqual([]);
+ await h.handle.send({ type: 'user', content: 'accepted fork input' });
+ await vi.waitFor(() => expect(h.events.filter(e => e.type === 'session_id')).toEqual([
+ { type: 'session_id', data: destination, source: 'claude-code' },
+ ]));
+ expect(h.handle.id).toBe(destination);
+ h.streams[0].emit({ type: 'system', subtype: 'init', session_id: destination });
+ await h.handle.close();
+ for (const stream of h.streams) stream.end();
+ await h.collected;
+ expect(h.events.filter(e => e.type === 'session_id')).toHaveLength(1);
+ });
+
+ it('rebuilds an unaccepted initial fork from the durable source after a directory change', async () => {
+ const clear = vi.fn(async () => true);
+ const h = await startHarness({ resumeSessionId: 'sdk-source', transcriptExists: true, onInvalidResumeSession: clear, forkSession: true });
+ const initialDestination = h.handle.requestSessionId;
+ await h.handle.setExtraDirs?.([await makeTempDir()]);
+ await h.handle.send({ type: 'user', content: 'accept after changing directories' });
+ expect(h.queryOptions[1]).toMatchObject({ resume: 'sdk-source', forkSession: true });
+ expect(h.queryOptions[1]).not.toHaveProperty('resumeSessionAt');
+ expect(h.queryOptions[1].sessionId).not.toBe(initialDestination);
+ expect(h.handle.id).toBe(h.queryOptions[1].sessionId);
+ expect(clear).not.toHaveBeenCalled();
+ await h.handle.close();
+ for (const stream of h.streams) stream.end();
+ await h.collected;
+ });
+
it('preflight missing clears the old id and starts fresh before any turn is sent', async () => {
const clear = vi.fn(async () => true);
const h = await startHarness({
@@ -226,6 +407,8 @@ describe('Claude invalid-resume recovery', () => {
expect(clear).toHaveBeenCalledWith('sdk-missing');
expect(h.queryOptions).toHaveLength(1);
expect(h.queryOptions[0]).not.toHaveProperty('resume');
+ expect(h.handle.id).toBe(h.queryOptions[0].sessionId);
+ expect(h.handle.id).not.toBe('sdk-missing');
await h.handle.close();
h.streams[0].end();
await h.collected;
@@ -256,6 +439,8 @@ describe('Claude invalid-resume recovery', () => {
// 失效 id 被清;重建的 query 不带 resume;没有 surface 任何终态错误。
expect(clear).toHaveBeenCalledWith('sdk-orphan');
expect(h.queryOptions[1]).not.toHaveProperty('resume');
+ expect(h.handle.id).toBe(h.queryOptions[1].sessionId);
+ expect(h.handle.id).not.toBe('sdk-orphan');
expect(h.events.filter((event) => event.type === 'error')).toHaveLength(0);
expect(h.events.some((event) => event.type === 'done')).toBe(false);
// idle 重建:首个 query 在失败前没消费任何输入,新 query 也还没有输入在跑。
diff --git a/packages/maker-core/src/agents/claude-code/__tests__/rewind-runtime-settings.test.ts b/packages/maker-core/src/agents/claude-code/__tests__/rewind-runtime-settings.test.ts
index 1a988619c6..2e88cd699b 100644
--- a/packages/maker-core/src/agents/claude-code/__tests__/rewind-runtime-settings.test.ts
+++ b/packages/maker-core/src/agents/claude-code/__tests__/rewind-runtime-settings.test.ts
@@ -2105,7 +2105,7 @@ describe('ClaudeCodeAgent runtime settings during rewind window', () => {
type: 'user',
content: [{ type: 'image', path: path.join(os.tmpdir(), 'slow-missing.png') }],
});
-
+ await vi.waitFor(() => expect(sdkMock.query).toHaveBeenCalledTimes(2));
const rebuildArgs = sdkMock.query.mock.calls[1]?.[0] as {
prompt: AsyncIterable<{ message?: { content?: unknown } }> & { pending: number };
};
@@ -2183,7 +2183,7 @@ describe('ClaudeCodeAgent runtime settings during rewind window', () => {
type: 'user',
content: [{ type: 'image', path: path.join(os.tmpdir(), 'compact-boundary-then-fail.png') }],
});
-
+ await vi.waitFor(() => expect(sdkMock.query).toHaveBeenCalledTimes(2));
const rebuildArgs = sdkMock.query.mock.calls[1]?.[0] as {
prompt: AsyncIterable<{ message?: { content?: unknown } }> & { pending: number };
};
@@ -2263,7 +2263,7 @@ describe('ClaudeCodeAgent runtime settings during rewind window', () => {
{ type: 'user', content: [{ type: 'image', path: path.join(os.tmpdir(), 'slow-stop.png') }] },
{ signal: controller.signal },
);
-
+ await vi.waitFor(() => expect(sdkMock.query).toHaveBeenCalledTimes(2));
const rebuildArgs = sdkMock.query.mock.calls[1]?.[0] as {
prompt: AsyncIterable<{ message?: { content?: unknown } }> & { pending: number };
};
@@ -2712,15 +2712,19 @@ describe('ClaudeCodeAgent runtime settings during rewind window', () => {
events.some((e) => e.type === 'done' && (e.data as { reason?: string }).reason === 'send_cancelled_before_acceptance'),
).toBe(true);
});
- expect(secondQuery.close).not.toHaveBeenCalled();
+ expect(secondQuery.close).toHaveBeenCalled();
const rebuildArgs = sdkMock.query.mock.calls[1]?.[0] as {
prompt: AsyncIterable<{ message?: { content?: unknown } }> & { pending: number };
};
expect(rebuildArgs.prompt.pending).toBe(0);
+ const retryQuery = createFakeQuery();
+ sdkMock.query.mockReturnValue(retryQuery);
await handle.send({ type: 'user', content: 'next after accept replay cancellation' });
- expect(sdkMock.query).toHaveBeenCalledTimes(2);
- const promptIter = rebuildArgs.prompt[Symbol.asyncIterator]();
+ expect(sdkMock.query).toHaveBeenCalledTimes(3);
+ const retryArgs = sdkMock.query.mock.calls[2]?.[0] as typeof rebuildArgs;
+ expect(sdkMock.query.mock.calls[2]?.[0]?.options?.resume).toBe(sdkMock.query.mock.calls[1]?.[0]?.options?.resume);
+ const promptIter = retryArgs.prompt[Symbol.asyncIterator]();
expect((await promptIter.next()).value?.message?.content).toBe('next after accept replay cancellation');
await handle.close();
diff --git a/packages/maker-core/src/agents/claude-code/__tests__/upstream-idle-watchdog.test.ts b/packages/maker-core/src/agents/claude-code/__tests__/upstream-idle-watchdog.test.ts
index d7f913443c..9a6466f16e 100644
--- a/packages/maker-core/src/agents/claude-code/__tests__/upstream-idle-watchdog.test.ts
+++ b/packages/maker-core/src/agents/claude-code/__tests__/upstream-idle-watchdog.test.ts
@@ -569,8 +569,17 @@ describe('Claude Code tool-loop guard runtime integration', () => {
'deepseek/deepseek-v4-flash',
);
await session.handle.setModel?.('claude-opus-5');
+ const rebuiltStream = createControlledStream();
+ const rebuiltQuery = createFakeQuery(rebuiltStream);
+ sdkMock.query.mockImplementationOnce((options: { prompt: AsyncIterable<unknown> }) => {
+ session.stream.end();
+ void (async () => {
+ for await (const item of options.prompt) { void item; }
+ })();
+ return rebuiltQuery;
+ });
const result = await runStableAbabLoop(
- session,
+ { ...session, stream: rebuiltStream, fakeQuery: rebuiltQuery },
'find the missing implementation after switching models',
'toolu_issue_2721_switch',
);
diff --git a/packages/maker-core/src/agents/claude-code/index.ts b/packages/maker-core/src/agents/claude-code/index.ts
index 2767680682..ae15331a68 100644
--- a/packages/maker-core/src/agents/claude-code/index.ts
+++ b/packages/maker-core/src/agents/claude-code/index.ts
@@ -24,6 +24,7 @@
import { LIBRARY_READ_ROOT, withLibraryNativeReadContext } from '../shared/library-native-read.js';
import { promises as fs } from 'node:fs';
+import { randomUUID } from 'node:crypto';
import os from 'node:os';
import path from 'node:path';
@@ -2908,6 +2909,10 @@ export class ClaudeCodeAgent extends BaseAgent {
// ── 跨 turn 共享状态 ───────────────────────────────────────────────────
let configuredResumeSessionId: string | undefined = opts.resumeSessionId;
let sdkSessionId: string | undefined = configuredResumeSessionId;
+ let durableSdkSessionId: string | undefined = configuredResumeSessionId;
+ let publishedSdkSessionId: string | undefined = configuredResumeSessionId;
+ let localQueryStarted = false;
+ const unacceptedForks = new WeakSet<Query>();
// 只在首次 resume 尚未被真实内容证明成功前允许自愈;成功一轮后即关闭分类窗口,
// 避免后续普通 turn 中碰巧出现同文案时误清上下文。
let resumeValidationPending = !!configuredResumeSessionId;
@@ -3355,9 +3360,8 @@ export class ClaudeCodeAgent extends BaseAgent {
if (state !== 'enabled') return '';
return registeredMcpServerNames.has('cindy_contacts') ? CONTACTS_RULES_ENABLED : '';
})();
- // resume 优先用当前的 sdkSessionId (rewind 重启时它指向上一轮 SDK 给的 id);
- // 缺省回到 startSession 入参的 resumeSessionId (新会话首次起 query 时用)。
- let resumeSdkSid = sdkSessionId ?? configuredResumeSessionId;
+ // A prebound request id is not a resume source until its input is accepted.
+ let resumeSdkSid = durableSdkSessionId ?? configuredResumeSessionId;
let modelUsageCumulativeStartsAtZero = !resumeSdkSid;
// ── 远端 cc 分支 (Phase 4.3) ──
@@ -4018,7 +4022,11 @@ export class ClaudeCodeAgent extends BaseAgent {
const botOwnSkillPluginRoots = reviewMode
? []
: [...new Set([...(managedPlugins?.roots ?? []), ...(opts.botRuntimeProfile?.skillPolicy.ownSkillPluginRoots ?? [])])];
- const createLocalQuery = () => sdkQuery({
+ // Bind the native request id before the first HTTP request, not after SDK init.
+ // A fork keeps its resume source but must publish a new destination id.
+ const newSdkSessionId = !resumeSdkSid || finalFork ? randomUUID() : undefined;
+ const previousSdkSessionId = sdkSessionId;
+ const createLocalQueryArgs = (): Parameters<typeof sdkQuery>[0] => ({
prompt: inputQueue as unknown as Parameters<typeof sdkQuery>[0]['prompt'],
options: {
abortController,
@@ -4073,6 +4081,7 @@ export class ClaudeCodeAgent extends BaseAgent {
};
})(),
...(resumeSdkSid ? { resume: resumeSdkSid } : {}),
+ ...(newSdkSessionId ? { sessionId: newSdkSessionId } : {}),
enableFileCheckpointing,
...(finalResumeAt ? { resumeSessionAt: finalResumeAt } : {}),
...(finalFork ? { forkSession: true } : {}),
@@ -4157,12 +4166,20 @@ export class ClaudeCodeAgent extends BaseAgent {
try {
companionEnvironment?.assertCurrent?.();
if (managedPlugins && querySignal.aborted) throw new Error('Claude session closed before skill plugins were loaded');
- query = createLocalQuery();
+ const queryArgs = createLocalQueryArgs();
+ if (newSdkSessionId) sdkSessionId = newSdkSessionId;
+ query = sdkQuery(queryArgs);
} catch (error) {
+ if (sdkSessionId === newSdkSessionId) sdkSessionId = previousSdkSessionId;
querySignal.removeEventListener('abort', releaseManagedPlugins);
if (managedPlugins) await managedPlugins.dispose();
throw error;
}
+ if (newSdkSessionId && finalFork && resumeSdkSid) {
+ unacceptedForks.add(query);
+ } else if (newSdkSessionId) {
+ durableSdkSessionId = newSdkSessionId;
+ }
if (managedPlugins) {
const closeQuery = query.close.bind(query);
query.close = () => {
@@ -4189,6 +4206,11 @@ export class ClaudeCodeAgent extends BaseAgent {
return applyFlagSettings(settings);
};
}
+ if (newSdkSessionId && localQueryStarted && !unacceptedForks.has(query)) {
+ publishedSdkSessionId = newSdkSessionId;
+ eventQueue.push({ type: 'session_id', data: newSdkSessionId, source: 'claude-code' });
+ }
+ localQueryStarted = true;
return query;
};
@@ -5268,8 +5290,14 @@ export class ClaudeCodeAgent extends BaseAgent {
getLogTitle: () => lastSendTitle,
tracker: usageTracker,
onSessionId: (sid) => {
- if (sid && sid !== sdkSessionId) {
+ if (sid && unacceptedForks.has(currentQ)) {
sdkSessionId = sid;
+ return;
+ }
+ if (sid && sid !== publishedSdkSessionId) {
+ sdkSessionId = sid;
+ durableSdkSessionId = sid;
+ publishedSdkSessionId = sid;
eventQueue.push({ type: 'session_id', data: sid, source: 'claude-code' });
}
},
@@ -5591,6 +5619,7 @@ export class ClaudeCodeAgent extends BaseAgent {
freshSessionValidationPending = false;
configuredResumeSessionId = undefined;
sdkSessionId = undefined;
+ durableSdkSessionId = undefined;
log.warn('invalid resume id cleared; switching to a fresh Claude conversation', {
expectedResumeSessionId, source,
});
@@ -5976,7 +6005,8 @@ export class ClaudeCodeAgent extends BaseAgent {
if (decision.unavailable) autoReviewUnavailableNotice.notify();
return decision;
},
- get id() { return sdkSessionId ?? '<pending>'; },
+ get id() { return durableSdkSessionId ?? '<pending>'; },
+ get requestSessionId() { return sdkSessionId ?? '<pending>'; },
agentKind: 'claude-code',
get model() { return mutableModel; },
@@ -6007,17 +6037,17 @@ export class ClaudeCodeAgent extends BaseAgent {
activeQueryDirectoryGeneration !== autoReviewDirectoryGeneration
&& !pendingRewindTo
&& !activeBridgeRewindResumeAt
- && sdkSessionId
+ && durableSdkSessionId
) {
- pendingRewindTo = sdkSessionId;
+ pendingRewindTo = durableSdkSessionId;
extraDirsRebuildAttempted = true;
} else if (
activeQueryExploreInheritCapGeneration !== exploreInheritCapEnvGeneration
&& !pendingRewindTo
&& !activeBridgeRewindResumeAt
- && sdkSessionId
+ && durableSdkSessionId
) {
- pendingRewindTo = sdkSessionId;
+ pendingRewindTo = durableSdkSessionId;
} else if (
extraDirsCopyFallbackEnabled
&& extraDirsRebuildAttempted
@@ -6115,6 +6145,7 @@ export class ClaudeCodeAgent extends BaseAgent {
// commitRewindFiles 只设标记, 真正的 SDK Query 重起延迟到这里 —— 老 agentManager
// 同款设计 (CLI 拿到 input 才会发 init, 避免"无 input → 30s timeout"死锁)。
let runtimeReplaySnapshot: QueryRuntimeSnapshot | undefined;
+ let rollbackUnacceptedFork: (() => void) | undefined;
const finishSendBeforeUserInput = (reason: string, error?: unknown): void => {
if (
bridgeCompactQueued &&
@@ -6147,9 +6178,13 @@ export class ClaudeCodeAgent extends BaseAgent {
acceptingRebuiltSend = false;
preserveBridgeRetryTarget(abandonedBridgeKind, abandonedRewindResumeAt);
emitTurnBoundary('bridge_send_abandoned', suppressedDoneData);
+ rollbackUnacceptedFork?.();
+ return;
+ }
+ if (!turnInFlight) {
+ rollbackUnacceptedFork?.();
return;
}
- if (!turnInFlight) return;
log.debug('send cancelled before user input was accepted — closing synthetic turn', {
reason,
error: error === undefined ? undefined : String(error),
@@ -6165,16 +6200,17 @@ export class ClaudeCodeAgent extends BaseAgent {
if (stopTerminalEmittedGeneration !== turnState.generation) {
emitTurnBoundary(reason);
}
+ rollbackUnacceptedFork?.();
};
if (pendingRewindTo || activeBridgeRewindResumeAt) {
const resumeAt = pendingRewindTo ?? activeBridgeRewindResumeAt;
if (!resumeAt) {
throw new Error('Claude rewind rebuild missing resume target');
}
- const directoryGrantRebuild = pendingRewindTo === sdkSessionId;
+ const directoryGrantRebuild = pendingRewindTo === durableSdkSessionId;
log.debug('send ▶ pendingRewindTo detected — rebuilding sdkQuery with 三件套', {
resumeSessionAt: directoryGrantRebuild ? undefined : resumeAt,
- resumeSdkSid: sdkSessionId,
+ resumeSdkSid: durableSdkSessionId,
directoryGrantRebuild,
});
// 关键: 重建 abortController + inputQueue。老的两个在 q.close() 时已经污染
@@ -6214,19 +6250,29 @@ export class ClaudeCodeAgent extends BaseAgent {
log.warn('rewind rebuild: q.close threw', { error: String(e) });
}
}
+ const forkSourceId = durableSdkSessionId;
q = await buildQuery({
...(directoryGrantRebuild ? {} : { resumeSessionAt: resumeAt }),
forkSession: true,
permissionMode: snapSdkPermissionMode,
});
- if (sendOpts?.signal?.aborted) {
+ const rebuiltQuery = q;
+ const forkDestinationId = sdkSessionId;
+ // Until the user input is accepted, a cancelled fork must retry its source.
+ rollbackUnacceptedFork = () => {
+ rollbackUnacceptedFork = undefined;
+ if (!forkSourceId || q !== rebuiltQuery || sdkSessionId !== forkDestinationId) return;
+ canceledBridgeQueries.add(rebuiltQuery);
+ recordCanceledQueryClose(rebuiltQuery, 'unaccepted fork');
inputQueue.end();
- canceledBridgeQueries.add(q);
- try {
- q.close();
- } catch (e) {
- log.warn('rewind rebuild cancellation: q.close threw', { error: String(e) });
- }
+ sdkSessionId = forkSourceId;
+ unacceptedForks.delete(rebuiltQuery);
+ pendingRewindTo = directoryGrantRebuild ? forkSourceId : resumeAt;
+ acceptingRebuiltSend = false;
+ clearBridgeState();
+ };
+ if (sendOpts?.signal?.aborted) {
+ rollbackUnacceptedFork();
throw new Error('Claude send cancelled before acceptance');
}
startForwardLoop(q);
@@ -6248,16 +6294,7 @@ export class ClaudeCodeAgent extends BaseAgent {
};
await replayRuntimeDrift(runtimeReplaySnapshot, 'rewind rebuild');
if (sendOpts?.signal?.aborted) {
- pendingRewindTo = resumeAt;
- clearBridgeState();
- acceptingRebuiltSend = false;
- inputQueue.end();
- canceledBridgeQueries.add(q);
- try {
- q.close();
- } catch (e) {
- log.warn('rewind rebuild replay cancellation: q.close threw', { error: String(e) });
- }
+ rollbackUnacceptedFork();
throw new Error('Claude send cancelled before acceptance');
}
// 补触发 auto-compact (Codex review P2):
@@ -6368,6 +6405,14 @@ export class ClaudeCodeAgent extends BaseAgent {
throw new Error('Claude input queue is closed');
}
userInputAccepted = true;
+ rollbackUnacceptedFork = undefined;
+ if (unacceptedForks.delete(q) && sdkSessionId) {
+ durableSdkSessionId = sdkSessionId;
+ if (publishedSdkSessionId !== sdkSessionId) {
+ publishedSdkSessionId = sdkSessionId;
+ eventQueue.push({ type: 'session_id', data: sdkSessionId, source: 'claude-code' });
+ }
+ }
activeCapabilitySelectionText = userMessageTextForCapabilityRouting(message.content);
setAutoReviewIntent(appendAutoReviewUserIntent(priorAutoReviewIntent(), message.content, sendOpts), { authority: autoReviewContext() });
replayableUserInput = sdkInput;
diff --git a/packages/maker-core/src/maker.test.ts b/packages/maker-core/src/maker.test.ts
index d2b6dd2921..02f65f22b0 100644
--- a/packages/maker-core/src/maker.test.ts
+++ b/packages/maker-core/src/maker.test.ts
@@ -562,6 +562,21 @@ describe('Maker local Pi package generation fence', () => {
});
describe('Maker session creation singleflight', () => {
+ it('persists the durable resume id while exposing a distinct transient request id', async () => {
+ const storage = createStorage();
+ const handle = { ...createHandle({ id: 'sdk-source', agentKind: 'claude-code' }), requestSessionId: 'sdk-unaccepted-fork' };
+ const maker = new Maker({
+ agents: { 'claude-code': createAgent(async () => handle, 'claude-code') },
+ storage, logger: createLogger(),
+ });
+ const session = await maker.createSession({ id: 'fork-task', agentKind: 'claude-code', workingDir: '/fixture', model: 'grok-4.6' });
+ expect(session.sdkSessionId).toBe('sdk-source');
+ expect(session.requestSessionId).toBe('sdk-unaccepted-fork');
+ expect((await storage.get('fork-task'))?.sdkSessionId).toBe('sdk-source');
+ await maker.closeSession('fork-task');
+ expect((await storage.get('fork-task'))?.sdkSessionId).toBe('sdk-source');
+ });
+
it('reports the effective runtime cwd when recovering an existing task elsewhere', async () => {
const storage = createStorage();
await storage.create({ id: 'recovered-cwd', agentKind: 'codex', workDir: '/original', title: 'Existing task', model: 'test-model' });
diff --git a/packages/maker-core/src/session.ts b/packages/maker-core/src/session.ts
index 8b1ed52d7a..cae945648c 100644
--- a/packages/maker-core/src/session.ts
+++ b/packages/maker-core/src/session.ts
@@ -1585,14 +1585,18 @@ export class Session {
}
/**
- * 底层 agent handle 的会话 id —— cc = SDK session id(也是出站请求的 `x-claude-code-session-id`
- * header 值);SDK 尚未回填时为 '<pending>'。只读、不触发任何行为,供 host 把 loopback proxy
- * 看到的请求归属回本会话做 per-session 路由(见 maker-host/anthropic-compat-proxy-host.ts)。
+ * Native identity safe to persist for resume. An unaccepted fork retains its source.
+ * Request routing uses requestSessionId, which may already identify the destination.
*/
get sdkSessionId(): string {
return this.handle.id;
}
+ /** Live request identity, which may precede a fork's durable resume identity. */
+ get requestSessionId(): string {
+ return this.handle.requestSessionId ?? this.handle.id;
+ }
+
/** 当前运行时模型。底层 handle 的 getter 会随 setModel 成功更新。 */
get model(): string {
return this.handle.model;