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(pi): preserve providers and serialize cache learning

xuzini-xzn6d9e2b8d4e1c
diff --git a/apps/desktop/src/main/maker-host/__tests__/pi-native-compat-overrides-store.test.ts b/apps/desktop/src/main/maker-host/__tests__/pi-native-compat-overrides-store.test.ts
index cd06fda68a..5968bb8ece 100644
--- a/apps/desktop/src/main/maker-host/__tests__/pi-native-compat-overrides-store.test.ts
+++ b/apps/desktop/src/main/maker-host/__tests__/pi-native-compat-overrides-store.test.ts
@@ -1,4 +1,9 @@
import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import { spawn } from 'node:child_process';
+import { once } from 'node:events';
+import { PI_CACHE_RECOVERY_SOURCE } from '../../../../../../packages/maker-core/src/agents/pi/cache-recovery-source.js';
+import { withCrossProcessLock } from '../../device-link/crossProcessLock.js';
import os from 'node:os';
import path from 'node:path';
import { afterAll, beforeEach, describe, expect, it, vi } from 'vitest';
@@ -80,3 +85,185 @@ describe('learned cache compatibility', () => {
expect(fs.existsSync(file)).toBe(false);
});
});
+
+
+// Real child processes execute the production bridge wrapper. A controlled
+// rename barrier holds one writer after its disk read, reproducing lost updates
+// without relying on scheduler timing; the other writer must observe the lock.
+function cacheProcess(id: string, options: { pause?: boolean; failWrite?: boolean } = {}) {
+ const release = path.join(root.path, 'release-' + id);
+ const script = `
+import * as fs from 'node:fs';
+import path from 'node:path';
+import { createHash, randomUUID } from 'node:crypto';
+import { runInNewContext } from 'node:vm';
+import { createInterface } from 'node:readline';
+process.send = value => console.log(JSON.stringify(value));
+const file = ${JSON.stringify(file)}, release = ${JSON.stringify(release)};
+const model = { provider: 'fixture', id: ${JSON.stringify(id)}, api: 'openai-completions', baseUrl: 'http://127.0.0.1/v1' };
+const key = JSON.stringify(['child', model.id, 'c'.repeat(64)]);
+const rule = JSON.stringify([{ ...model, providerId: 'child', routeKey: 'c'.repeat(64) }]);
+const ruleFile = path.join('/fixture', 'pi-cache-compatibility.json');
+const handlers = new Map();
+const registry = { getProvider() {}, getRegisteredNativeProvider() {} };
+let pendingTimers = 0;
+let calls = 0, pause = ${Boolean(options.pause)}, failWrite = ${Boolean(options.failWrite)};
+const api = runInNewContext(${JSON.stringify(PI_CACHE_RECOVERY_SOURCE + '\ninstallCindyCacheRecovery(pi)')}, {
+ ...fs, path, process: { pid: process.pid, uptime: () => process.uptime(), kill: (...a) => process.kill(...a),
+ env: { PI_CODING_AGENT_DIR: '/fixture', CINDY_PI_CACHE_COMPAT_FILE: file } },
+ createHash, randomUUID, Buffer, clearTimeout, Date,
+ setTimeout: (fn, ms) => {
+ pendingTimers++;
+ return setTimeout(() => {
+ pendingTimers--; fn();
+ setImmediate(() => { if (!pendingTimers) process.send({ event: 'persistence-idle' }); });
+ }, ms);
+ }, homedir: () => '/fixture',
+ pi: { on: (event, fn) => handlers.set(event, fn) },
+ statSync: name => name === ruleFile ? { size: rule.length } : fs.statSync(name),
+ readFileSync: (name, ...a) => name === ruleFile ? rule : fs.readFileSync(name, ...a),
+ writeFileSync: (name, ...a) => {
+ if (failWrite && typeof name === 'string' && name.endsWith('.tmp')) throw new Error('fixture write failure');
+ return fs.writeFileSync(name, ...a);
+ },
+ renameSync: (from, to) => {
+ if (to === file && pause) {
+ pause = false; process.send({ event: 'before-rename' });
+ const deadline = Date.now() + 5000;
+ while (!fs.existsSync(release)) {
+ if (Date.now() >= deadline) throw new Error('barrier timed out');
+ Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 5);
+ }
+ }
+ return fs.renameSync(from, to);
+ },
+});
+api.ownRegistry?.(registry);
+function start() {
+ handlers.get('before_agent_start')({});
+ handlers.get('message_start')({ message: { role: 'user', content: [{ type: 'text', text: 'OK' }] } }, { modelRegistry: registry });
+}
+async function request() {
+ const sent = [];
+ const invoke = async function* (options) {
+ calls++;
+ const payload = await options.onPayload({ model: model.id, prompt_cache_key: 'cache' }, model);
+ sent.push(payload);
+ if (payload.prompt_cache_key) yield { type: 'error', error: { stopReason: 'error', content: [], errorMessage: '400: {"error":{"message":"opaque refusal","type":"invalid_request_error"}}' } };
+ else yield { type: 'done', message: { stopReason: 'stop', content: [{ type: 'text', text: 'OK' }] } };
+ };
+ const events = [];
+ for await (const event of api.wrap(model, {}, invoke)) events.push(event.type);
+ return { calls, sent, events };
+}
+createInterface({ input: process.stdin }).on('line', async command => {
+ try {
+ if (command === 'start') { start(); process.send({ event: 'success', ...await request() }); }
+ if (command === 'next') { failWrite = false; start(); process.send({ event: 'next', ...await request() }); }
+ if (command === 'stop') { process.stdin.destroy(); }
+ } catch (error) { process.send({ event: 'error', message: String(error) }); process.exitCode = 1; process.stdin.destroy(); }
+});
+process.send({ event: 'ready', key });
+`;
+ const scriptFile = path.join(root.path, 'child-' + id + '.mjs');
+ fs.writeFileSync(scriptFile, script);
+ const child = spawn(process.execPath, [scriptFile], { stdio: ['pipe', 'pipe', 'pipe'] });
+ let stderr = '';
+ child.stderr!.on('data', data => { stderr += data; });
+ const messages: any[] = [];
+ let stdout = '';
+ child.stdout!.on('data', data => {
+ stdout += data;
+ let newline;
+ while ((newline = stdout.indexOf('\n')) >= 0) {
+ messages.push(JSON.parse(stdout.slice(0, newline))); stdout = stdout.slice(newline + 1);
+ }
+ });
+ const send = (command: string) => child.stdin!.write(command + '\n');
+ return {
+ child, release, send,
+ async event(name: string) {
+ await vi.waitFor(() => {
+ expect(child.exitCode, stderr).toBeNull();
+ expect(messages.find(message => message.event === 'error'), stderr).toBeUndefined();
+ expect(messages.some(message => message.event === name), stderr).toBe(true);
+ }, { timeout: 2000 });
+ return messages.find(message => message.event === name);
+ },
+ async stop() {
+ fs.writeFileSync(release, 'release');
+ if (child.exitCode === null) { const exited = once(child, 'exit'); child.kill(); await exited; }
+ fs.rmSync(release, { force: true });
+ },
+ };
+}
+
+describe('native and Desktop cache writers share one lock', () => {
+ it.each(['native', 'desktop'])('merges an overlapping %s writer after a native read', async writer => {
+ const first = cacheProcess('first', { pause: true });
+ const second = writer === 'native' ? cacheProcess('second') : undefined;
+ try {
+ await first.event('ready');
+ if (second) await second.event('ready');
+ first.send('start');
+ await first.event('before-rename');
+ let attempted = false;
+ const open = fsp.open.bind(fsp);
+ const spy = vi.spyOn(fsp, 'open').mockImplementation((...args: Parameters<typeof fsp.open>) => {
+ if (args[0] === file + '.lock') attempted = true;
+ return open(...args);
+ });
+ const other = second
+ ? (second.send('start'), second.event('success'))
+ : record('desktop', 'second', fix, b);
+ if (second) await other;
+ else await vi.waitFor(() => expect(attempted).toBe(true));
+ spy.mockRestore();
+ fs.writeFileSync(first.release, 'release');
+ expect((await first.event('success')).events).toEqual(['done']);
+ await other;
+ await vi.waitFor(() => expect(Object.keys(JSON.parse(fs.readFileSync(file, 'utf8')).routes)).toHaveLength(2));
+ const records = JSON.parse(fs.readFileSync(file, 'utf8')).routes;
+ expect(records[JSON.stringify(['child', 'first', 'c'.repeat(64)])]).toMatchObject({ evidence: 'opaque' });
+ expect(records[JSON.stringify(writer === 'native' ? ['child', 'second', 'c'.repeat(64)] : ['desktop', 'second', b])]).toBeDefined();
+ } finally { vi.restoreAllMocks(); await first.stop(); await second?.stop(); }
+ });
+
+ it('returns successful generation while Desktop owns the lock, then merges after release', async () => {
+ const native = cacheProcess('waiting');
+ try {
+ await native.event('ready');
+ await withCrossProcessLock(file + '.lock', { label: 'fixture' }, async status => {
+ expect(status.held).toBe(true);
+ native.send('start');
+ expect((await native.event('success')).events).toEqual(['done']);
+ // Actual Desktop writer queues behind this same lock, as does native.
+ expect(fs.existsSync(file)).toBe(false);
+ });
+ expect(await record('desktop', 'other', fix, b)).toBe(true);
+ await vi.waitFor(() => expect(Object.keys(JSON.parse(fs.readFileSync(file, 'utf8')).routes)).toHaveLength(2));
+ } finally { await native.stop(); }
+ });
+
+ it.each(['busy', 'write', 'corrupt'])('keeps success and memory learning after %s persistence failure', async failure => {
+ if (failure === 'busy') fs.writeFileSync(file + '.lock', JSON.stringify({ pid: process.pid, nonce: 'fixture-owner', startedAt: Date.now() }));
+ if (failure === 'corrupt') fs.writeFileSync(file, '{bad-json');
+ const native = cacheProcess('failure', { failWrite: failure === 'write' });
+ try {
+ await native.event('ready');
+ native.send('start');
+ const result = await native.event('success');
+ expect(result.events).toEqual(['done']); expect(result.calls).toBe(2);
+ if (failure === 'corrupt') expect(fs.readFileSync(file, 'utf8')).toBe('{bad-json');
+ // Wait until the bounded lock attempt ends before allowing persistence.
+ if (failure === 'busy') await native.event('persistence-idle');
+ fs.rmSync(file + '.lock', { force: true });
+ if (failure === 'corrupt') fs.rmSync(file);
+ native.send('next');
+ const next = await native.event('next');
+ expect(next.events).toEqual(['done']); expect(next.calls).toBe(3);
+ expect(next.sent).toEqual([{ model: 'failure' }]);
+ await vi.waitFor(() => expect(Object.keys(JSON.parse(fs.readFileSync(file, 'utf8')).routes)).toHaveLength(1));
+ } finally { await native.stop(); fs.rmSync(file + '.lock', { force: true }); }
+ });
+});
diff --git a/apps/desktop/src/main/provider-group/__tests__/coolingStore.test.ts b/apps/desktop/src/main/provider-group/__tests__/coolingStore.test.ts
index b96b294008..9965910772 100644
--- a/apps/desktop/src/main/provider-group/__tests__/coolingStore.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/coolingStore.test.ts
@@ -116,9 +116,11 @@ describe('writeProviderGroupCooling (real file)', () => {
const members = Object.fromEntries(Array.from({ length: PROVIDER_GROUP_STORAGE_MEMBER_CAP }, (_, i) => [
`device:${String(i).padStart(164, 'd')}:${providerId}`, scopes,
]));
- await coolingStore.writeProviderGroupCooling({ [providerId]: members });
+ coolingStore.writeProviderGroupCooling({ [providerId]: members });
const file = path.join(caseDir, 'provider-group-cooling.json');
- expect(JSON.parse(fs.readFileSync(file, 'utf8')).cooling[providerId]).toEqual(members);
+ await vi.waitFor(() => {
+ expect(JSON.parse(fs.readFileSync(file, 'utf8')).cooling[providerId]).toEqual(members);
+ });
expect(fs.statSync(file).size).toBeGreaterThan(1024 * 1024);
// 新实例没有旧 store 的缓存,直接从实际文件恢复。
// reset-modules: verify persisted cooldowns survive a fresh store instance.
@@ -133,11 +135,11 @@ describe('writeProviderGroupCooling (real file)', () => {
const now = Date.now();
const studioUntil = now + 120_000;
const miniUntil = now + 60_000;
- await Promise.all([
- coolingStore.writeProviderGroupCooling({ anthropic: { 'device:studio:a': { '': studioUntil } } }),
- coolingStore.writeProviderGroupCooling({ anthropic: { 'device:mini:a': { '': miniUntil } } }),
- ]);
- expect(coolingStore.readProviderGroupCooling().anthropic).toEqual({ 'device:studio:a': { '': studioUntil }, 'device:mini:a': { '': miniUntil } });
+ coolingStore.writeProviderGroupCooling({ anthropic: { 'device:studio:a': { '': studioUntil } } });
+ coolingStore.writeProviderGroupCooling({ anthropic: { 'device:mini:a': { '': miniUntil } } });
+ await vi.waitFor(() => {
+ expect(coolingStore.readProviderGroupCooling().anthropic).toEqual({ 'device:studio:a': { '': studioUntil }, 'device:mini:a': { '': miniUntil } });
+ });
});
it('旧文件的 512 个已过期成员释放容量,新成员冷却写盘并在重启后保留', async () => {
@@ -148,8 +150,10 @@ describe('writeProviderGroupCooling (real file)', () => {
const current = { anthropic: { 'device:studio:a': { '': now + 120_000 } } };
fs.writeFileSync(file, JSON.stringify({ cooling: { ...current, openai: expired } }));
const next = { 'device:new:openai': { '': now + 60_000 } };
- await coolingStore.writeProviderGroupCooling({ openai: next });
- expect(JSON.parse(fs.readFileSync(file, 'utf8')).cooling.openai).toEqual(next);
+ coolingStore.writeProviderGroupCooling({ openai: next });
+ await vi.waitFor(() => {
+ expect(JSON.parse(fs.readFileSync(file, 'utf8')).cooling.openai).toEqual(next);
+ });
// reset-modules: verify persisted cooldowns survive a fresh store instance.
vi.resetModules();
const restarted = await import('../coolingStore.js');
diff --git a/apps/desktop/src/main/provider-group/coolingStore.ts b/apps/desktop/src/main/provider-group/coolingStore.ts
index 85f45347cc..9d80269f85 100644
--- a/apps/desktop/src/main/provider-group/coolingStore.ts
+++ b/apps/desktop/src/main/provider-group/coolingStore.ts
@@ -90,9 +90,9 @@ function mergeCooling(
return merged;
}
-/** 合并写入;返回实际落盘完成信号,后台调用仍可忽略,失败只记日志。 */
-export function writeProviderGroupCooling(cooling: ProviderGroupPersistedCooling): Promise<void> {
- return store.updateAtomic((current) => normalize({ cooling: mergeCooling(current.value.cooling, cooling) })).then(() => undefined).catch((error: unknown) => {
+/** 合并写入(调用方只给还没到期的);写不下去只记日志,本次运行照常避开。 */
+export function writeProviderGroupCooling(cooling: ProviderGroupPersistedCooling): void {
+ void store.updateAtomic((current) => normalize({ cooling: mergeCooling(current.value.cooling, cooling) })).catch((error: unknown) => {
log.warn('provider group: saving cooldowns failed', { error: error instanceof Error ? error.message : String(error) });
});
}
diff --git a/packages/maker-core/src/agents/pi/__tests__/cache-compatibility.integration.test.ts b/packages/maker-core/src/agents/pi/__tests__/cache-compatibility.integration.test.ts
index a803b53a05..a16a598666 100644
--- a/packages/maker-core/src/agents/pi/__tests__/cache-compatibility.integration.test.ts
+++ b/packages/maker-core/src/agents/pi/__tests__/cache-compatibility.integration.test.ts
@@ -1,9 +1,11 @@
import { createServer } from 'node:http';
+import { spawnSync } from 'node:child_process';
+import { PI_NATIVE_PROVIDER_ADAPTER_SOURCE } from '../native-provider-adapter-source.js';
import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
import os from 'node:os';
import path from 'node:path';
import { fileURLToPath } from 'node:url';
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
import { PiAgent } from '../index.js';
import type { AgentDeps, AgentSessionHandle } from '../../base-agent.js';
import type { AgentEvent } from '../../../types/events.js';
@@ -26,6 +28,160 @@ function responses() {
// Integration tier: public PiAgent -> generated bridge -> official Pi -> loopback
// HTTP, covering #5878/#6570/#6649, both adapters, one transcript input and TTL.
describe.skipIf(!existsSync(binary))('Pi cache recovery over real native RPC/HTTP', () => {
+ // #7561: real Pi registry, not a mock of its registration semantics. The
+ // former object wrapper destroyed name/config registrations even without 400.
+ it('preserves both registration forms, model headers, class receivers and later owners', () => {
+ const root = mkdtempSync(path.join(os.tmpdir(), 'cindy-provider-registration-'));
+ const output = path.join(root, 'result.json');
+ const extension = path.join(root, 'probe.ts');
+ const probe = String.raw`
+import { writeFileSync } from 'node:fs';
+import { envApiKeyAuth } from '@earendil-works/pi-ai';
+const CINDY_HOSTED = null;
+PRODUCTION_ADAPTER
+export default function(pi) {
+ pi.on('session_start', async (_event, ctx) => {
+ const calls = [];
+ let wraps = 0;
+ const model = { id: 'fixture', name: 'Fixture', provider: 'fixture-provider', api: 'openai-completions',
+ baseUrl: 'http://127.0.0.1:9', reasoning: false, input: ['text'], contextWindow: 32768, maxTokens: 32,
+ cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 } };
+ const handle = async function* (name, m, c, o) {
+ const payload = await o.onPayload?.({ custom_serializer: name, model: m.id }, m);
+ calls.push({ name, headers: o.headers, apiKey: o.apiKey, payload });
+ yield { type: 'done', message: { stopReason: 'stop', content: [] } };
+ };
+ class OriginalProvider {
+ #name;
+ id = model.provider;
+ name = 'Fixture';
+ constructor(name) { this.#name = name; }
+ get auth() { return { apiKey: envApiKeyAuth('key', ['FIXTURE_KEY']) }; }
+ getModels() { void this.#name; return [model]; }
+ stream(m,c,o) { return handle(this.#name + ':full',m,c,o); }
+ streamSimple(m,c,o) { return handle(this.#name + ':simple',m,c,o); }
+ }
+ try {
+ const config = { api: model.api, apiKey: 'fixture-key', baseUrl: model.baseUrl,
+ headers: { 'x-provider': 'provider-header' },
+ models: [{ ...model, headers: { 'x-model': 'model-header' } }],
+ streamSimple: (m,c,o) => handle('config',m,c,o) };
+ pi.registerProvider(model.provider, config);
+ await ctx.modelRegistry.refresh({ allowNetwork: false });
+ const savedConfig = ctx.modelRegistry.getRegisteredProviderConfig(model.provider);
+ let installed;
+ const adapter = await registerCindyNativeProviderAdapters({
+ ...pi, on: (event, fn) => { if(event === 'session_start') installed = fn; },
+ }, { accepts: m => m.provider === model.provider, ownRegistry() {},
+ wrap: (m,o,invoke) => { wraps++; return invoke(o); } });
+ await installed({},ctx);
+ const run = async (simple = true) => {
+ const selected = ctx.modelRegistry.find(model.provider, model.id);
+ const request = await ctx.modelRegistry.runtime.prepareRequest(selected, { onPayload: p => ({ ...p, hook: true }) });
+ for await (const _event of request.provider[simple ? 'streamSimple' : 'stream'](request.model, { messages: [] }, request.options)) {}
+ };
+ await run();
+ await adapter.refresh({ nonce: 'refresh', env: {}, aliases: [] }, ctx, new Set());
+ await run(false);
+ const retained = ctx.modelRegistry.getRegisteredProviderConfig(model.provider) === savedConfig;
+ pi.registerProvider(Object.freeze(new OriginalProvider('native')));
+ await ctx.modelRegistry.refresh({ allowNetwork: false });
+ await run();
+ await adapter.refresh({ nonce: 'native', env: {}, aliases: [] }, ctx, new Set());
+ await run(false);
+ pi.registerProvider(Object.freeze(new OriginalProvider('later')));
+ await adapter.refresh({ nonce: 'next', env: {}, aliases: [] }, ctx, new Set());
+ await run();
+ const later = ctx.modelRegistry.getRegisteredNativeProvider(model.provider).name === 'Fixture';
+ pi.unregisterProvider(model.provider);
+ await adapter.refresh({ nonce: 'removed', env: {}, aliases: [] }, ctx, new Set());
+ const removed = !ctx.modelRegistry.getRegisteredNativeProvider(model.provider)
+ && !ctx.modelRegistry.getRegisteredProviderConfig(model.provider);
+ writeFileSync(process.env.FIXTURE_OUTPUT, JSON.stringify({ calls, wraps, retained, later, removed }));
+ process.exit(0);
+ } catch(error) { writeFileSync(process.env.FIXTURE_OUTPUT, JSON.stringify({ error: String(error), stack: error.stack })); process.exit(1); }
+ });
+}
+`;
+ try {
+ writeFileSync(extension, probe.replace('PRODUCTION_ADAPTER', PI_NATIVE_PROVIDER_ADAPTER_SOURCE));
+ const child = spawnSync(binary, ['--mode', 'rpc', '--no-extensions', '-e', extension, '--no-skills', '--no-prompt-templates', '--no-themes', '--no-context-files', '--no-tools'], {
+ cwd: root, input: '', timeout: 20000, encoding: 'utf8',
+ env: { ...process.env, HOME: root, USERPROFILE: root, PI_CODING_AGENT_DIR: root, PI_OFFLINE: '1',
+ PI_SKIP_VERSION_CHECK: '1', CINDY_PI_NATIVE_PROVIDER_ADAPTERS: '[]', FIXTURE_KEY: 'fixture-key', FIXTURE_OUTPUT: output },
+ });
+ const result = existsSync(output) ? JSON.parse(readFileSync(output, 'utf8')) : { stderr: child.stderr, error: child.error?.message };
+ expect({ status: child.status, error: result.error }).toEqual({ status: 0, error: undefined });
+ expect(result).toMatchObject({ retained: true, later: true, removed: true, wraps: 5 });
+ expect(result.calls.map((call: any) => call.name)).toEqual(['config', 'config', 'native:simple', 'native:full', 'later:simple']);
+ for (const call of result.calls) {
+ expect(call.apiKey).toBe('fixture-key');
+ expect(call.payload).toEqual({ custom_serializer: call.name, model: 'fixture', hook: true });
+ }
+ for (const call of result.calls.slice(0,2)) expect(call.headers).toMatchObject({ 'x-provider': 'provider-header', 'x-model': 'model-header' });
+ } finally { rmSync(root, { recursive: true, force: true }); }
+ }, 30000);
+
+ it('merges learning from two official Pi processes sharing one execution-side store', async () => {
+ const root = mkdtempSync(path.join(os.tmpdir(), 'cindy-cache-concurrent-'));
+ const storeFile = path.join(root, 'compat.json');
+ const handles: AgentSessionHandle[] = [];
+ const successful: Array<() => void> = [];
+ const requests = new Map<string, number>();
+ const gateway = createServer(async (req, res) => {
+ let raw = ''; for await (const chunk of req) raw += chunk;
+ const payload = JSON.parse(raw);
+ const route = req.url!;
+ requests.set(route, (requests.get(route) ?? 0) + 1);
+ if ('prompt_cache_key' in payload || 'prompt_cache_retention' in payload) {
+ res.writeHead(400, { 'content-type': 'application/json' });
+ res.end(JSON.stringify({ error: { message: 'opaque refusal', type: 'invalid_request_error' } }));
+ return;
+ }
+ // Both native processes finish the contrast together, before either can
+ // learn from the other's file. This complements the exact rename barrier.
+ successful.push(() => { res.writeHead(200, { 'content-type': 'text/event-stream' }); res.end(responses()); });
+ if (successful.length === 2) for (const finish of successful) finish();
+ });
+ try {
+ await new Promise<void>(resolve => gateway.listen(0, '127.0.0.1', resolve));
+ const address = gateway.address(); if (!address || typeof address === 'string') throw new Error('missing listener');
+ await Promise.all(['a', 'b'].map(async id => {
+ const workingDir = path.join(root, 'work-' + id); mkdirSync(workingDir);
+ const deps: AgentDeps = {
+ binaryPath: binary, logger,
+ auth: { getState: async () => ({ authenticated: true, identity: 'fixture', authSource: 'api-key' }), triggerLogin: async () => ({ authenticated: true }), logout: async () => {}, getAuthEnv: async () => ({}) },
+ runtimeConfig: { endpoint: 'http://127.0.0.1:0' },
+ resolvePiAgentHome: () => path.join(root, 'agent-' + id),
+ resolvePiNativeCompatStorePath: () => storeFile,
+ resolvePiNativeProviders: async () => ({ providers: [{ id, sourceProviderId: id, name: id,
+ apiKeyEnvVar: 'CINDY_PI_KEY_FIXTURE', baseUrl: 'http://127.0.0.1:' + address.port + '/' + id + '/api.openai.com/v1',
+ api: 'openai-responses', models: [{ id: 'fixture', contextWindow: 32768, maxTokens: 100 }] }],
+ env: { CINDY_PI_KEY_FIXTURE: 'fixture-key' } }),
+ preparePiExtraSpawnConfig: async () => ({ mcpEnv: { HOME: root, USERPROFILE: root, XDG_CONFIG_HOME: path.join(root, 'xdg') } }),
+ };
+ const handle = await new PiAgent(deps).startSession({ workingDir, sessionId: id,
+ model: 'fixture', providerId: id, permissionMode: 'bypassPermissions' });
+ handles.push(handle);
+ const events: AgentEvent[] = [];
+ const finish = (async () => { for await (const event of handle.events()) { events.push(event); if (event.type === 'done') break; } })();
+ await handle.send({ type: 'user', content: 'Reply OK' });
+ await finish;
+ expect(events.filter(event => event.type === 'done')).toHaveLength(1);
+ expect(events.some(event => event.type === 'error')).toBe(false);
+ }));
+ await vi.waitFor(() => expect(Object.keys(JSON.parse(readFileSync(storeFile, 'utf8')).routes)).toHaveLength(2));
+ const routes = JSON.parse(readFileSync(storeFile, 'utf8')).routes;
+ expect(Object.keys(routes).map(key => JSON.parse(key)[0]).sort()).toEqual(['a', 'b']);
+ expect([...requests.values()]).toEqual([2, 2]);
+ } finally {
+ gateway.closeAllConnections();
+ await Promise.all(handles.map(handle => handle.close()));
+ await new Promise<void>(resolve => gateway.close(() => resolve()));
+ rmSync(root, { recursive: true, force: true });
+ }
+ }, 60000);
+
it.each(['openai-completions', 'openai-responses'].flatMap(api => [
{ api, mode: 'opaque', rejection: { error: { message: 'opaque refusal', type: 'invalid_request_error', param: null } } },
{ api, mode: 'explicit', rejection: { message: '未知请求字段:prompt_cache_retention', type: 'invalid_request_error' } },
diff --git a/packages/maker-core/src/agents/pi/__tests__/cache-recovery.test.ts b/packages/maker-core/src/agents/pi/__tests__/cache-recovery.test.ts
index f4b9fe2141..6201246778 100644
--- a/packages/maker-core/src/agents/pi/__tests__/cache-recovery.test.ts
+++ b/packages/maker-core/src/agents/pi/__tests__/cache-recovery.test.ts
@@ -23,9 +23,16 @@ function fixture(legacy = false) {
files.set('/agent/pi-cache-compatibility.json', JSON.stringify(rules));
let writeFails = false;
const fs = {
+ mkdirSync() {}, rmdirSync() {}, closeSync() {}, readdirSync: () => [],
+ openSync: (name: string) => {
+ if (files.has(name)) throw Object.assign(new Error('exists'), { code: 'EEXIST' });
+ files.set(name, ''); return name;
+ },
+ linkSync: (from: string, to: string) => { files.set(to, files.get(from)!); },
+ lstatSync: (name: string) => fs.statSync(name),
statSync: (name: string) => {
if (!files.has(name)) throw Object.assign(new Error('missing'), { code: 'ENOENT' });
- return { size: Buffer.byteLength(files.get(name)!), mtimeMs: 1000 };
+ return { size: Buffer.byteLength(files.get(name)!), mtimeMs: 1000, dev: 1, ino: 1, isFile: () => true };
},
readFileSync: (name: string) => { fs.statSync(name); return files.get(name); },
writeFileSync: (name: string, text: string) => { if (writeFails) throw new Error('read-only'); files.set(name, text); },
@@ -34,10 +41,11 @@ function fixture(legacy = false) {
};
const api = runInNewContext(PI_CACHE_RECOVERY_SOURCE + '\ninstallCindyCacheRecovery(pi)', {
pi: { on: (name: string, fn: (...args: any[]) => void) => handlers.set(name, fn) },
- process: { env: { PI_CODING_AGENT_DIR: '/agent', CINDY_PI_CACHE_COMPAT_FILE: '/compat.json' } },
+ process: { pid: 123, uptime: () => 1, kill() {}, env: { PI_CODING_AGENT_DIR: '/agent', CINDY_PI_CACHE_COMPAT_FILE: '/compat.json' } },
// The in-memory filesystem uses POSIX keys on every host, including Windows.
...fs, path: path.posix, createHash, randomUUID, Buffer, setTimeout, clearTimeout, Date: { now: () => now }, homedir: () => '/home/fixture',
});
+ if (!legacy) api.ownRegistry(modernRegistry);
const startUser = (direct = true, followUp = false) => {
if (direct) handlers.get('before_agent_start')?.({});
handlers.get('message_start')?.({ message: { role: 'user', content: [{ type: 'text', text: 'OK' }] } }, {
@@ -98,7 +106,8 @@ describe('Pi native cache recovery', () => {
const recovered = restarted.handlers.get('before_provider_request')!;
expect(await recovered({ payload }, ctx)).not.toHaveProperty('prompt_cache_key');
expect(await recovered({ payload }, { ...ctx, model: { ...selected, baseUrl: selected.baseUrl + '/other' } })).toBeUndefined();
- expect(await recovered({ payload }, { ...ctx, modelRegistry: { ...ctx.modelRegistry, getRegisteredNativeProvider: vi.fn() } })).toBeUndefined();
+ restarted.api.ownRegistry(modernRegistry);
+ expect(await recovered({ payload }, { ...ctx, modelRegistry: modernRegistry })).toBeUndefined();
restarted.clock(1086400001);
// Expiry cannot change a tool continuation in the already-started input.
restarted.handlers.get('tool_execution_start')!();
diff --git a/packages/maker-core/src/agents/pi/__tests__/nativeProviderAdapterRefresh.test.ts b/packages/maker-core/src/agents/pi/__tests__/nativeProviderAdapterRefresh.test.ts
index 8340a149b5..e16785a979 100644
--- a/packages/maker-core/src/agents/pi/__tests__/nativeProviderAdapterRefresh.test.ts
+++ b/packages/maker-core/src/agents/pi/__tests__/nativeProviderAdapterRefresh.test.ts
@@ -4,12 +4,12 @@ import { describe, expect, it, vi } from 'vitest';
import { CINDY_BRIDGE_EXTENSION_SOURCE } from '../cindy-bridge-source.js';
import { nativeProviderAdapterAliases, PI_NATIVE_PROVIDER_ADAPTER_SOURCE } from '../native-provider-adapter-source.js';
-type RegisteredProvider = { id: string; auth: { apiKey?: unknown; oauth?: unknown }; getModels: () => unknown[];
+type RegisteredProvider = { id: string; auth: { apiKey?: unknown; oauth?: unknown }; getModels: () => unknown[]; filterModels?: () => unknown;
streamSimple(model: unknown, context: unknown, options: unknown): Promise<unknown> | AsyncIterable<unknown> };
type Alias = { id: string; name: string; provider: string; keyEnv?: string; remoteProviderId?: string; models?: Array<{ id: string; grant: string }> };
-function loadAdapter(initialAliases: Alias[] = [], network?: { fetch: unknown; stream: unknown; guest?: boolean }) {
+function loadAdapter(initialAliases: Alias[] = [], network?: { fetch: unknown; stream: RegisteredProvider['streamSimple']; guest?: boolean }) {
const env: Record<string, string> = {
CINDY_PI_NATIVE_PROVIDER_ADAPTERS: JSON.stringify(initialAliases),
CINDY_PI_KEY_OLD: 'old-secret',
@@ -34,11 +34,12 @@ function loadAdapter(initialAliases: Alias[] = [], network?: { fetch: unknown; s
let nextModels = models;
const ctx = {
modelRegistry: {
+ runtime: { async prepareRequest(model: any, options: any) { return { model, options, provider: ctx.modelRegistry.getProvider(model.provider) }; } },
getAll: () => models,
getRegisteredNativeProvider: (id: string) => providers.get(id),
getProvider: (id: string) => providers.get(id) ?? ({ id, name: id, auth: { apiKey: 'preserved-auth' },
getModels: () => models.filter(model => model.provider === id),
- filterModels: () => [], stream: network?.stream, streamSimple: network?.stream }),
+ filterModels: () => [], stream: network?.stream, streamSimple: network?.stream ?? (async function* () {}) }),
async refresh(options: { allowNetwork?: boolean }) {
expect(options).toEqual({ allowNetwork: false });
actions.push('refresh');
@@ -79,13 +80,14 @@ describe('Cindy native provider refresh bridge', () => {
h.setModels([{ provider: 'managed', id: 'wire' }, { provider: 'extension-owned', id: 'other' }]);
await h.ctx.modelRegistry.refresh({ allowNetwork: false });
const wrap = vi.fn((model, options, invoke) => invoke(options));
- await h.adapter.registerCindyNativeProviderAdapters(h.pi, { accepts: (model: any) => model.provider === 'managed', wrap });
+ await h.adapter.registerCindyNativeProviderAdapters(h.pi, { accepts: (model: any) => model.provider === 'managed', wrap, ownRegistry: vi.fn() });
await h.handlers.get('session_start')!({}, h.ctx);
- expect([...h.providers.keys()]).toEqual(['managed']);
- expect(h.providers.get('managed')).toMatchObject({ auth: { apiKey: 'preserved-auth' }, filterModels: expect.any(Function) });
+ expect([...h.providers.keys()]).toEqual([]);
const model = { provider: 'managed', id: 'wire', api: 'openai-responses' };
const options = { apiKey: 'fixture-key', onPayload: vi.fn() };
- await h.providers.get('managed')!.streamSimple(model, { messages: [] }, options);
+ const prepared = await h.ctx.modelRegistry.runtime.prepareRequest(model, options);
+ expect(prepared.provider.auth).toEqual({ apiKey: 'preserved-auth' });
+ await prepared.provider.streamSimple(prepared.model, { messages: [] }, prepared.options);
expect(wrap).toHaveBeenCalledWith(model, options, expect.any(Function), 'managed');
expect(stream).toHaveBeenCalledWith(model, { messages: [] }, options);
});
@@ -101,13 +103,13 @@ describe('Cindy native provider refresh bridge', () => {
const original = provider('original-extension');
const replacement = provider('newer-extension');
h.pi.registerProvider(original);
- const adapter = await h.adapter.registerCindyNativeProviderAdapters(h.pi, { accepts: () => true,
+ const adapter = await h.adapter.registerCindyNativeProviderAdapters(h.pi, { accepts: () => true, ownRegistry: vi.fn(),
wrap: (_model: unknown, options: unknown, invoke: any) => invoke(options) });
await h.handlers.get('session_start')!({}, h.ctx);
if (owner === 'newer') h.pi.registerProvider(replacement);
if (owner === 'removed') h.pi.unregisterProvider('managed');
await adapter.refresh({ nonce: 'refresh', env: {}, aliases: [] }, h.ctx, new Set());
- const current = h.providers.get('managed')!;
+ const current = (await h.ctx.modelRegistry.runtime.prepareRequest({ provider: 'managed', id: 'wire', api: 'openai-responses' }, {})).provider;
if (owner === 'removed') {
expect(current.auth).toEqual({ apiKey: 'preserved-auth' });
expect(original.streamSimple).not.toHaveBeenCalled();
@@ -115,7 +117,8 @@ describe('Cindy native provider refresh bridge', () => {
}
const expected = owner === 'newer' ? replacement : original;
expect(current.auth).toBe(expected.auth);
- expect(current).toMatchObject({ filterModels: expected.filterModels });
+ current.filterModels!();
+ expect(expected.filterModels).toHaveBeenCalledOnce();
await current.streamSimple({ provider: 'managed', id: 'wire', api: 'openai-responses' }, { messages: [] }, {});
expect(expected.streamSimple).toHaveBeenCalledOnce();
expect(fallbackStream).not.toHaveBeenCalled();
@@ -125,7 +128,7 @@ describe('Cindy native provider refresh bridge', () => {
h.setModels([{ provider: 'managed', id: 'wire' }]);
await h.ctx.modelRegistry.refresh({ allowNetwork: false });
(h.ctx.modelRegistry as any)[missing] = undefined;
- await h.adapter.registerCindyNativeProviderAdapters(h.pi, { accepts: () => true });
+ await h.adapter.registerCindyNativeProviderAdapters(h.pi, { accepts: () => true, ownRegistry: vi.fn() });
await h.handlers.get('session_start')!({}, h.ctx);
expect(h.providers.size).toBe(0);
});
diff --git a/packages/maker-core/src/agents/pi/cache-recovery-source.ts b/packages/maker-core/src/agents/pi/cache-recovery-source.ts
index 9d2c39e280..fcc0135f86 100644
--- a/packages/maker-core/src/agents/pi/cache-recovery-source.ts
+++ b/packages/maker-core/src/agents/pi/cache-recovery-source.ts
@@ -3,8 +3,8 @@ export const PI_CACHE_RECOVERY_SOURCE = String.raw`
function installCindyCacheRecovery(pi) {
const supported = (api) => api === 'openai-completions' || api === 'openai-responses';
const fields = ['prompt_cache_key', 'prompt_cache_retention'];
- const nativeRegistry = ctx => typeof ctx?.modelRegistry?.getProvider === 'function'
- && typeof ctx.modelRegistry.getRegisteredNativeProvider === 'function';
+ const ownedRegistries = new WeakSet();
+ const nativeRegistry = ctx => ownedRegistries.has(ctx?.modelRegistry);
const day = 24 * 60 * 60 * 1000;
const home = process.env.CINDY_PI_CACHE_COMPAT_FILE;
const file = home && home.replace(/^\$HOME(?=\/)/, () => homedir());
@@ -60,18 +60,112 @@ function installCindyCacheRecovery(pi) {
&& ['explicit', 'opaque'].includes(record.evidence)
&& record.expiresAt <= record.learnedAt + (record.evidence === 'explicit' ? 7 : 1) * day && record.expiresAt > now;
}
- function remember(key, evidence, startedAt) {
- const record = { supportsLongCacheRetention: false, evidence, learnedAt: startedAt,
- expiresAt: startedAt + (evidence === 'explicit' ? 7 : 1) * day };
- if ((memory[key]?.learnedAt ?? 0) > startedAt) return;
- memory[key] = record;
- if (!file) return record;
+ // Participate in Desktop's ordinary advisory protocol, not its security lock.
+ // Only acquisition waits; the held read/merge/rename/release has no await.
+ function lockSnapshot(name) {
+ try {
+ const info = lstatSync(name);
+ if (!info.isFile() || info.size > 4096) return;
+ const text = readFileSync(name, 'utf8');
+ let record;
+ try { record = JSON.parse(text); } catch {}
+ return { info, text, record };
+ } catch { return; }
+ }
+ function dead(pid) {
+ if (!Number.isInteger(pid) || pid <= 0) return false;
+ try { process.kill(pid, 0); return false; } catch (error) { return error?.code === 'ESRCH'; }
+ }
+ function stale(snapshot) {
+ return snapshot && Date.now() - snapshot.info.mtimeMs > 10000
+ && (!Number.isInteger(snapshot.record?.pid) || snapshot.record.pid <= 0 || dead(snapshot.record.pid));
+ }
+ function sameLock(left, right) {
+ return left && right && ['dev', 'ino', 'size', 'mtimeMs'].every(key => left.info[key] === right.info[key])
+ && left.text === right.text;
+ }
+ function gateBusy(lock, ownGate) {
+ // Legacy gates are still observed by released Desktop versions.
+ try {
+ lstatSync(lock + '.reclaim');
+ if (!stale(lockSnapshot(lock + '.reclaim'))) return true;
+ } catch (error) { if (error?.code !== 'ENOENT') return true; }
+ let entries;
+ try { entries = readdirSync(lock + '.reclaim.d'); }
+ catch (error) { return error?.code !== 'ENOENT'; }
+ const active = [];
+ for (const entry of entries) {
+ if (!entry.startsWith('gate-') || !entry.endsWith('.json')) continue;
+ const name = path.join(lock + '.reclaim.d', entry);
+ const snapshot = lockSnapshot(name);
+ if (!snapshot) return true;
+ const record = snapshot.record;
+ if (record?.state === 'released') continue;
+ if (stale(snapshot)) {
+ const pid = Number(/^gate-(\d+)-/.exec(entry)?.[1]);
+ if (record?.pid || dead(pid)) continue;
+ }
+ if (!Number.isFinite(record?.startedAt) || typeof record?.nonce !== 'string') return true;
+ active.push({ name, record });
+ }
+ active.sort((a, b) => a.record.startedAt - b.record.startedAt || a.record.nonce.localeCompare(b.record.nonce)
+ || a.name.localeCompare(b.name));
+ return active.length > 0 && active[0].name !== ownGate;
+ }
+ function reclaim(lock) {
+ const candidate = lockSnapshot(lock);
+ if (!stale(candidate)) return;
+ const nonce = randomUUID();
+ const directory = lock + '.reclaim.d';
+ mkdirSync(directory, { recursive: true });
+ const gate = path.join(directory, 'gate-' + process.pid + '-' + nonce + '.json');
+ const record = { pid: process.pid, startedAt: Date.now(), nonce, state: 'held',
+ processStartIdentity: 'start-ms:' + Math.round(Date.now() - process.uptime() * 1000) };
+ writeFileSync(gate, JSON.stringify(record), { flag: 'wx', mode: 0o600 });
+ const isolated = lock + '.stale-' + nonce;
+ try {
+ if (gateBusy(lock, gate) || !sameLock(lockSnapshot(lock), candidate)) return;
+ renameSync(lock, isolated);
+ if (sameLock(lockSnapshot(isolated), candidate)) rmSync(isolated);
+ else { try { linkSync(isolated, lock); rmSync(isolated); } catch {} }
+ } finally {
+ // Unique nonce names are never reused; a failed cleanup is recoverable
+ // after process exit, and cannot remove a different owner's gate.
+ try { rmSync(gate); } catch {}
+ try { rmdirSync(directory); } catch {}
+ }
+ }
+ async function persist(key, record) {
+ if (!file) return;
+ const lock = file + '.lock';
+ const nonce = randomUUID();
+ const deadline = Date.now() + 1000;
+ let held = false;
let temporary;
try {
+ mkdirSync(path.dirname(file), { recursive: true });
+ do {
+ try {
+ if (!gateBusy(lock)) {
+ const fd = openSync(lock, 'wx', 0o600);
+ held = true;
+ try { writeFileSync(fd, JSON.stringify({ pid: process.pid, startedAt: Date.now(), nonce })); }
+ catch (error) { rmSync(lock); held = false; throw error; }
+ finally { closeSync(fd); }
+ if (!gateBusy(lock)) break;
+ rmSync(lock); held = false;
+ }
+ } catch (error) {
+ if (!['EEXIST', 'EBUSY', 'EPERM', 'EACCES'].includes(error?.code)) throw error;
+ reclaim(lock);
+ }
+ if (Date.now() >= deadline) return;
+ await new Promise(resolve => setTimeout(resolve, 40));
+ } while (true);
const current = load();
- if (!current || (current.routes[key]?.learnedAt ?? 0) > startedAt) return;
+ if (!current || (current.routes[key]?.learnedAt ?? 0) > record.learnedAt) return;
for (const [otherKey, otherRecord] of Object.entries(current.routes)) {
- if (Number.isFinite(otherRecord?.expiresAt) && otherRecord.expiresAt <= startedAt) delete current.routes[otherKey];
+ if (Number.isFinite(otherRecord?.expiresAt) && otherRecord.expiresAt <= record.learnedAt) delete current.routes[otherKey];
}
current.routes[key] = record;
const data = JSON.stringify(current);
@@ -79,9 +173,21 @@ function installCindyCacheRecovery(pi) {
temporary = file + '.' + randomUUID() + '.tmp';
writeFileSync(temporary, data, { mode: 0o600, flag: 'wx' });
renameSync(temporary, file);
- delete memory[key];
+ if (memory[key] === record) delete memory[key];
} catch { /* Storage failure must never undo a successful response. */ }
- finally { if (temporary) { try { rmSync(temporary, { force: true }); } catch {} } }
+ finally {
+ if (temporary) { try { rmSync(temporary, { force: true }); } catch {} }
+ if (held) {
+ try { if (lockSnapshot(lock)?.record?.nonce === nonce) rmSync(lock); } catch {}
+ }
+ }
+ }
+ function remember(key, evidence, startedAt) {
+ const record = { supportsLongCacheRetention: false, evidence, learnedAt: startedAt,
+ expiresAt: startedAt + (evidence === 'explicit' ? 7 : 1) * day };
+ if ((memory[key]?.learnedAt ?? 0) > startedAt) return;
+ memory[key] = record;
+ void persist(key, record);
return record;
}
function withoutCache(payload) {
@@ -188,6 +294,7 @@ function installCindyCacheRecovery(pi) {
// Pi represents both steer and followUp as user messages. Snapshot now,
// but decide ownership only after the supervisor sees the public event.
invalidate();
+ for (const [key, record] of Object.entries(memory)) void persist(key, record);
const inputRules = readRules();
const records = load()?.routes ?? Object.create(null);
for (const [key, record] of Object.entries(memory)) {
@@ -255,6 +362,7 @@ function installCindyCacheRecovery(pi) {
});
return {
refreshRules,
+ ownRegistry: registry => ownedRegistries.add(registry),
accepts: model => Boolean(route(model)),
wrap(model, options, invoke, provider = model.provider) {
return (async function* () {
diff --git a/packages/maker-core/src/agents/pi/cindy-bridge-source.ts b/packages/maker-core/src/agents/pi/cindy-bridge-source.ts
index 14d3bd532e..9efc4903fa 100644
--- a/packages/maker-core/src/agents/pi/cindy-bridge-source.ts
+++ b/packages/maker-core/src/agents/pi/cindy-bridge-source.ts
@@ -83,7 +83,7 @@ export const CINDY_BRIDGE_EXTENSION_SOURCE = String.raw`/**
*/
import {
closeSync, globSync, lstatSync, openSync, opendirSync, readFileSync, realpathSync,
- renameSync, rmSync, statSync, writeFileSync,
+ renameSync, rmSync, statSync, writeFileSync, mkdirSync, readdirSync, rmdirSync, linkSync,
} from 'node:fs';
import { createHash, randomUUID } from 'node:crypto';
import { homedir } from 'node:os';
diff --git a/packages/maker-core/src/agents/pi/native-provider-adapter-source.ts b/packages/maker-core/src/agents/pi/native-provider-adapter-source.ts
index 72ac8b545a..65f33637a3 100644
--- a/packages/maker-core/src/agents/pi/native-provider-adapter-source.ts
+++ b/packages/maker-core/src/agents/pi/native-provider-adapter-source.ts
@@ -94,7 +94,8 @@ async function registerCindyNativeProviderAdapters(pi: any, cacheRecovery?: any)
if (Array.isArray(initial)) aliases = initial;
} catch { /* A malformed startup hint cannot affect other Pi extensions. */ }
const registered = new Set<string>();
- const cacheRegistrations = new Map<string, { original: any; installed: any }>();
+ let cacheRuntime: any;
+ let wrappedPrepare: any;
let apis: { lazyStream: any; envApiKeyAuth: any; getApiProvider: any } | undefined;
async function loadApis() {
if (!apis) {
@@ -109,20 +110,7 @@ async function registerCindyNativeProviderAdapters(pi: any, cacheRecovery?: any)
function registerAliases(models: any[], currentAliases: CindyAdapterAlias[], ctx: any) {
if (!apis) throw new Error('Native provider adapter is unavailable');
const { lazyStream, envApiKeyAuth, getApiProvider } = apis;
- const preserved = new Map<string, any>();
- const automatic = cacheRecovery ? [...new Set(models.filter((model: any) => cacheRecovery.accepts(model)).map((model: any) => model.provider))]
- .filter(id => !currentAliases.some(alias => alias.id === id))
- .flatMap(id => {
- if (typeof ctx.modelRegistry.getRegisteredNativeProvider !== 'function') return [];
- const original = ctx.modelRegistry.getProvider?.(id);
- // Older runtimes without this API keep their original provider intact.
- if (!original || typeof original.stream !== 'function' || typeof original.streamSimple !== 'function') return [];
- preserved.set(id, original);
- return [{ id, name: original.name ?? id, provider: id }];
- }) : [];
- for (const alias of [...currentAliases, ...automatic]) {
- const original = preserved.get(alias.id);
- const nativeOriginal = original ? ctx.modelRegistry.getRegisteredNativeProvider(alias.id) : undefined;
+ for (const alias of currentAliases) {
const providerModels = models.filter((model: any) => model.provider === alias.id
&& (!alias.models || alias.models.some(allowed => allowed.id === model.id)));
if (providerModels.length === 0 && !alias.models) continue;
@@ -137,7 +125,7 @@ async function registerCindyNativeProviderAdapters(pi: any, cacheRecovery?: any)
});
if (!response.ok || (await response.json()).allowed !== true) throw new Error('The model is not authorized for this remote task');
}
- const api = original ?? getApiProvider(model.api);
+ const api = getApiProvider(model.api);
if (!api) throw new Error('The selected native provider API is unavailable');
const nativeModel = { ...model, provider: alias.provider };
const nativeContext = { ...context, messages: context.messages.map((message: any) =>
@@ -172,24 +160,53 @@ async function registerCindyNativeProviderAdapters(pi: any, cacheRecovery?: any)
};
})();
});
- pi.registerProvider({ ...original, id: alias.id, name: alias.name,
+ pi.registerProvider({ id: alias.id, name: alias.name,
// Pi's native Provider contract requires auth even when Cindy's proxy handles OAuth.
- auth: original?.auth ?? (alias.keyEnv ? { apiKey: envApiKeyAuth('API key', [alias.keyEnv]) } : {}),
- getModels: original ? () => original.getModels() : () => providerModels,
+ auth: alias.keyEnv ? { apiKey: envApiKeyAuth('API key', [alias.keyEnv]) } : {},
+ getModels: () => providerModels,
stream: (model: any, context: any, options: any) => stream(model, context, options, false),
streamSimple: (model: any, context: any, options: any) => stream(model, context, options, true),
});
- if (original) cacheRegistrations.set(alias.id, { original: nativeOriginal,
- installed: ctx.modelRegistry.getRegisteredNativeProvider(alias.id) });
registered.add(alias.id);
}
}
+ function installCacheRequests(ctx: any) {
+ // Pi 1.x exposes a registry facade, while its own requests use this runtime.
+ // Wrap only the prepared request: registering a composed Provider would
+ // erase config registrations and their request-time model headers.
+ const registry = ctx.modelRegistry;
+ const runtime = registry?.runtime;
+ if (!cacheRecovery || typeof runtime?.prepareRequest !== 'function'
+ || typeof registry.getProvider !== 'function' || typeof registry.getRegisteredNativeProvider !== 'function') return;
+ if (cacheRuntime === runtime && runtime.prepareRequest === wrappedPrepare) return;
+ const prepare = runtime.prepareRequest;
+ wrappedPrepare = async function(this: any, ...args: any[]) {
+ const prepared = await prepare.apply(this, args);
+ if (!cacheRecovery.accepts(prepared.model)
+ || aliases.some(alias => alias.id === prepared.model.provider)) return prepared;
+ const original = prepared.provider;
+ if (typeof original?.stream !== 'function' || typeof original.streamSimple !== 'function') return prepared;
+ const provider = new Proxy({}, { get(_target, property) {
+ if (property === 'stream' || property === 'streamSimple') {
+ return (model: any, context: any, options: any) => apis!.lazyStream(model, async () =>
+ cacheRecovery.wrap(model, options, (next: any) => original[property].call(original, model, context, next), original.id));
+ }
+ const value = Reflect.get(original, property, original);
+ return typeof value === 'function' ? value.bind(original) : value;
+ } });
+ return { ...prepared, provider };
+ };
+ runtime.prepareRequest = wrappedPrepare;
+ cacheRuntime = runtime;
+ cacheRecovery.ownRegistry(registry);
+ }
if (aliases.length) await loadApis();
pi.on('session_start', async (_event: any, ctx: any) => {
const models = ctx.modelRegistry.getAll();
if (aliases.length || cacheRecovery && models.some((model: any) => cacheRecovery.accepts(model))) {
if (!apis) await loadApis();
registerAliases(models, aliases, ctx);
+ installCacheRequests(ctx);
}
});
return {
@@ -207,18 +224,8 @@ async function registerCindyNativeProviderAdapters(pi: any, cacheRecovery?: any)
process.env[name] = value;
secretEnvNames.add(name);
}
- for (const id of registered) {
- const registration = cacheRegistrations.get(id);
- if (!registration) pi.unregisterProvider(id);
- else if (ctx.modelRegistry.getRegisteredNativeProvider(id) === registration.installed) {
- // Unregister restores built-ins, not a prior extension registration.
- // Restore that registration only while this wrapper still owns it.
- if (registration.original) pi.registerProvider(registration.original);
- else pi.unregisterProvider(id);
- }
- }
+ for (const id of registered) pi.unregisterProvider(id);
registered.clear();
- cacheRegistrations.clear();
const result = await ctx.modelRegistry.refresh({ allowNetwork: false });
if (result?.aborted || result?.errors?.size) throw new Error('Native provider catalog refresh failed');
aliases = snapshot.aliases;
@@ -231,6 +238,7 @@ async function registerCindyNativeProviderAdapters(pi: any, cacheRecovery?: any)
// public refresh so the receipt reflects the final provider snapshot.
const final = await ctx.modelRegistry.refresh({ allowNetwork: false });
if (final?.aborted || final?.errors?.size) throw new Error('Native provider adapter refresh failed');
+ installCacheRequests(ctx);
},
};
}