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(providers): authorize same-account remote subroutes

DavidShen8d8ca9ee381c
diff --git a/apps/desktop/src/main/maker-host/__tests__/claudeProxyGuestRoute.test.ts b/apps/desktop/src/main/maker-host/__tests__/claudeProxyGuestRoute.test.ts
index 5cad19ffc3..642313fa2e 100644
--- a/apps/desktop/src/main/maker-host/__tests__/claudeProxyGuestRoute.test.ts
+++ b/apps/desktop/src/main/maker-host/__tests__/claudeProxyGuestRoute.test.ts
@@ -62,7 +62,7 @@ import {
setProviderOAuthTokenReader,
setProviderViewsReader,
} from '../provider-route';
-import { clearAllSessionProviders, getSessionProvider } from '../session-provider-store';
+import { bindHostedSessionProvider, clearAllSessionProviders, getSessionProvider } from '../session-provider-store';
import { registerPiProxySession } from '../pi-proxy-session-auth';
const SHARED_UPSTREAM = 'https://shared.example/api/anthropic';
@@ -265,7 +265,7 @@ describe('Claude proxy routing for shared-provider guests', () => {
// Unit regression for #6592 / provider-sharing §12: the production routing transform must
// deny an ungranted Pi model before any upstream/native handler. Earlier coverage only
// changed providers. Minimal failure: two models at one provider, only the first granted.
- it.each(['shared-a', 'openai', 'xai', 'xd'])('rechecks live Pi model grants for %s root and child routes', async providerId => {
+ it.each(['guest', 'owner'].flatMap(trust => ['shared-a', 'openai', 'xai', 'xd'].map(providerId => ({ trust, providerId }))))('rechecks live Pi model grants for $trust $providerId root and child routes', async ({ trust, providerId }) => {
const models = getActiveCatalog().providers.find(provider => provider.id === providerId)!.models.pi!;
const [first, second] = models.filter(model => !model.disabled);
expect(first).toBeDefined();
@@ -273,7 +273,8 @@ describe('Claude proxy routing for shared-provider guests', () => {
const wireId = (id: string) => providerId === 'openai' ? id.replace(/^chatgpt\//, '')
: providerId === 'xai' ? id.replace(/^xai\//, '') : id;
let allowedModel = first.id;
- registerGuestProviderRoute('pi-model-guest', providerId, model => model === allowedModel);
+ if (trust === 'guest') registerGuestProviderRoute('pi-model-guest', providerId, model => model === allowedModel);
+ else bindHostedSessionProvider('pi-model-guest', providerId, (id, model) => id === providerId && model === allowedModel);
registerGuestProviderRoute('other-person', providerId, () => false);
const disposers = [
registerPiProxySession('pi-model-guest', 'root-token', () => providerId),
@@ -327,6 +328,20 @@ describe('Claude proxy routing for shared-provider guests', () => {
}
});
+ it('allows an authorized owner child provider independently of the parent provider', async () => {
+ let childAllowed = true;
+ bindHostedSessionProvider('owner-parent', 'shared-a', (providerId, model) => childAllowed && providerId === 'other-b' && model === 'other-model');
+ const dispose = registerPiProxySession('owner-parent', 'owner-child', () => 'other-b', { scope: 'subagent-route' });
+ const request = () => transform({ model: 'other-model' }, ctxWith({
+ 'x-cindy-pi-session-id': 'owner-parent', 'x-cindy-pi-session-token': 'owner-child', 'x-cindy-pi-provider-id': 'other-b',
+ }));
+ try {
+ expect(await request()).toMatchObject({ upstreamOverride: OTHER_UPSTREAM });
+ childAllowed = false;
+ expect(await statusOf(await request())).toBe(403);
+ } finally { dispose(); }
+ });
+
it('keeps requests without a route token on the existing routing (same-account unchanged)', async () => {
const decision = await Promise.resolve(transform({ model: 'other-model' }, ctxWith({ 'x-api-key': 'sk-gw' })));
expect(decision).toMatchObject({
diff --git a/apps/desktop/src/main/maker-host/__tests__/codexProxyGuestRoute.test.ts b/apps/desktop/src/main/maker-host/__tests__/codexProxyGuestRoute.test.ts
index 33a65e6728..b17b61e268 100644
--- a/apps/desktop/src/main/maker-host/__tests__/codexProxyGuestRoute.test.ts
+++ b/apps/desktop/src/main/maker-host/__tests__/codexProxyGuestRoute.test.ts
@@ -29,11 +29,12 @@ vi.mock('../logger-adapter', () => ({
import { buildUserProvider } from '@cindy/model-providers';
import type { RoutingDecision } from '@cindy/anthropic-compat-proxy';
-import { setCustomProviders } from '../active-catalog';
-import { createCodexGuestRoutingGuard, registerComposed, registerReviewerRouteContext, unregister } from '../codex-proxy-host';
-import { CODEX_CUSTOM_PROVIDER_ROUTE_ROOT } from '../codex-custom-provider-route';
+import { getActiveCatalog, setCustomProviders, setDiscoveredCodexModels } from '../active-catalog';
+import { createCodexGuestRoutingGuard, createModelRoutingTransform, registerComposed, registerReviewerRouteContext, unregister } from '../codex-proxy-host';
+import { CODEX_CUSTOM_PROVIDER_ROUTE_ROOT, deriveCodexCustomProviderRoutes } from '../codex-custom-provider-route';
import { registerGuestProviderRoute, resetGuestProviderRoutesForTest } from '../guest-provider-route-store';
-import { clearAllSessionProviders, setSessionProvider } from '../session-provider-store';
+import { bindHostedSessionProvider, clearAllSessionProviders, setSessionProvider } from '../session-provider-store';
+import { setCustomProviderKeyReader } from '../provider-route';
function ctx(url: string, headers: Record<string, string> = {}, method = 'POST') {
return { reqId: 1, method, url, headers } as never;
@@ -62,9 +63,27 @@ describe('Codex proxy guard for shared-provider guests', () => {
afterEach(() => {
unregister('guest-session');
unregister('owner-session');
+ unregister('local-session');
resetGuestProviderRoutesForTest();
clearAllSessionProviders();
setCustomProviders([]);
+ setCustomProviderKeyReader(() => null);
+ setDiscoveredCodexModels([]);
+ });
+
+ it('authorizes an owner Guardian request using the registered parent model', async () => {
+ let allowed = true;
+ const parentModel = 'gpt-5.5';
+ setDiscoveredCodexModels([{ id: parentModel, name: parentModel, contextWindow: 272000, efforts: [], defaultEffort: null }]);
+ bindHostedSessionProvider('owner-session', 'openai', (providerId, model) => allowed && providerId === 'openai' && model === parentModel);
+ registerReviewerRouteContext('owner-session', 'owner-thread', parentModel);
+ const transform = createModelRoutingTransform('oauth-bearer');
+ const request = () => transform({ model: 'codex-auto-review' }, ctx('/responses', {
+ 'thread-id': 'owner-review', 'x-openai-subagent': 'guardian', 'x-codex-parent-thread-id': 'owner-thread',
+ }));
+ expect(await request()).toMatchObject({ upstreamOverride: 'https://chatgpt.com/backend-api/codex' });
+ allowed = false;
+ expect(await statusOf(await request())).toBe(403);
});
it('lets a guest request for a shared model continue to the session route', () => {
@@ -92,6 +111,38 @@ describe('Codex proxy guard for shared-provider guests', () => {
expect(await statusOf(guard({ model: 'other-model' }, ctx(path, { 'thread-id': 'guest-thread' })))).toBe(403);
});
+ // Unit regression for review 4327641928 / provider-sharing §12. Guest-only tests
+ // missed same-account hosted requests. Minimum: authorized parent A and child B
+ // at the same provider; the production proxy must deny B and observe live grants.
+ it.each(['ordinary', 'custom'].flatMap(pathKind => ['shared-a', 'other-b'].map(childProvider => ({ pathKind, childProvider }))))('checks same-account child grants on $pathKind routes to $childProvider', async ({ pathKind, childProvider }) => {
+ setCustomProviders(['shared-a', 'other-b'].map(id => buildUserProvider({ id, name: id, runtimes: {
+ codex: { baseUrl: `https://${id}.example/v1`, wireProtocol: 'openai-responses', supportsImageGeneration: true,
+ models: ['shared-model', 'private-model'].map(id => ({ id, name: id })) },
+ } })));
+ setCustomProviderKeyReader(() => 'fixture-key');
+ let allowedModel = 'shared-model';
+ bindHostedSessionProvider('owner-session', 'shared-a', (id, model) => model === allowedModel && id === (model === 'shared-model' ? 'shared-a' : childProvider));
+ registerComposed('owner-session', 'owner-thread', 'prompt', {
+ subagentRoute: { providerId: childProvider, catalogModel: 'private-model', reasoningEffort: null },
+ });
+ const routes = deriveCodexCustomProviderRoutes(getActiveCatalog());
+ const path = pathKind === 'custom' ? `${CODEX_CUSTOM_PROVIDER_ROUTE_ROOT}/${routes[0].routeId}/responses` : '/responses';
+ const transform = createModelRoutingTransform('env-key', routes);
+ const request = (child: boolean) => transform({ model: 'shared-model' }, ctx(path, child ? {
+ 'thread-id': 'owner-child', 'x-openai-subagent': 'collab_spawn', 'x-codex-parent-thread-id': 'owner-thread',
+ } : { 'thread-id': 'owner-thread' }));
+ expect(await request(false)).toMatchObject({ upstreamOverride: 'https://shared-a.example/v1' });
+ expect(await statusOf(await request(true))).toBe(403);
+ allowedModel = 'private-model';
+ expect(await request(true)).toMatchObject({ upstreamOverride: `https://${childProvider}.example/v1` });
+ allowedModel = '';
+ expect(await statusOf(await request(true))).toBe(403);
+ setSessionProvider('local-session', 'shared-a');
+ registerComposed('local-session', 'local-thread', 'prompt');
+ expect(await transform({ model: 'private-model' }, ctx(path, { 'thread-id': 'local-thread' })))
+ .toMatchObject({ upstreamOverride: 'https://shared-a.example/v1' });
+ });
+
// Unit regression for review 4326610462: the public guard must authorize Guardian's
// actual reviewer model, including live revocation. Existing tests only sent catalog ids;
// the minimal failure is an allowlisted parent with the internal codex-auto-review marker.
diff --git a/apps/desktop/src/main/maker-host/__tests__/codexProxyHost.test.ts b/apps/desktop/src/main/maker-host/__tests__/codexProxyHost.test.ts
index cce57c78c4..dc30e5ef7b 100644
--- a/apps/desktop/src/main/maker-host/__tests__/codexProxyHost.test.ts
+++ b/apps/desktop/src/main/maker-host/__tests__/codexProxyHost.test.ts
@@ -2800,6 +2800,24 @@ describe('codex proxy host', () => {
);
});
+ // Review 4327641928 / unit: opaque WS frames would bypass the live remote model
+ // gate. Earlier transport tests had only local sessions; the minimum input is
+ // one registered hosted owner task on an OAuth proxy.
+ it('uses HTTP for hosted owner requests while preserving local WebSockets', async () => {
+ const host = await freshCodexProxyHost();
+ const { bindHostedSessionProvider } = await import('../session-provider-store');
+ mockState.createAnthropicCompatProxy.mockResolvedValueOnce({ url: 'http://127.0.0.1:43210', dispose: vi.fn(async () => undefined) });
+ await host.ensureCodexProxyReady();
+ host.setCodexProxyAuthInjection('oauth-bearer');
+ host.registerComposed('remote-owner', 'remote-thread', 'prompt');
+ const binding = bindHostedSessionProvider('remote-owner', 'openai', () => true);
+ try {
+ const resolve = mockState.createAnthropicCompatProxy.mock.calls[0][0].resolveWebSocketUpstream;
+ expect(resolve({ headers: { 'thread-id': 'remote-thread' } })).toBeNull();
+ expect(resolve({ headers: { 'thread-id': 'local-thread' } })).toBe('https://chatgpt.com/backend-api/codex');
+ } finally { binding.release(); }
+ });
+
it('forgets only the closing session websocket proofs before a provider-route resume', async () => {
const host = await freshCodexProxyHost();
const forgetWebSocketStateForThread = vi.fn(() => 1);
diff --git a/apps/desktop/src/main/maker-host/__tests__/sessionProviderStore.test.ts b/apps/desktop/src/main/maker-host/__tests__/sessionProviderStore.test.ts
index edcb8eb523..d2e4ca1b67 100644
--- a/apps/desktop/src/main/maker-host/__tests__/sessionProviderStore.test.ts
+++ b/apps/desktop/src/main/maker-host/__tests__/sessionProviderStore.test.ts
@@ -16,6 +16,8 @@ import {
freezeSessionProviderAtStart,
getSessionProvider,
hasSessionProvider,
+ hasHostedSessionModelAccess,
+ hostedSessionModelAllowed,
setSessionProvider,
} from '../session-provider-store';
@@ -23,19 +25,22 @@ describe('hosted provider binding lifecycle', () => {
beforeEach(() => clearAllSessionProviders());
it('keeps a replacement run registered despite late updates and cleanup from the old run', () => {
- const old = bindHostedSessionProvider('remote-task', 'fp');
- const current = bindHostedSessionProvider('remote-task', 'other');
+ const old = bindHostedSessionProvider('remote-task', 'fp', () => false);
+ const current = bindHostedSessionProvider('remote-task', 'other', (id, model) => id === 'other' && model === 'allowed');
old.setProvider('stale');
old.release();
expect(getSessionProvider('remote-task')).toBe('other');
+ expect(hostedSessionModelAllowed('remote-task', 'other', 'allowed')).toBe(true);
+ expect(hostedSessionModelAllowed('remote-task', 'other', 'denied')).toBe(false);
current.setProvider('fp');
expect(getSessionProvider('remote-task')).toBe('fp');
current.release();
expect(hasSessionProvider('remote-task')).toBe(false);
+ expect(hasHostedSessionModelAccess('remote-task')).toBe(false);
});
it.each(['session', 'account', 'overwrite'] as const)('invalidates late callbacks on %s cleanup', (boundary) => {
- const binding = bindHostedSessionProvider('remote-task', 'fp');
+ const binding = bindHostedSessionProvider('remote-task', 'fp', () => false);
if (boundary === 'session') clearSessionProvider('remote-task');
if (boundary === 'account') clearAllSessionProviders();
if (boundary === 'overwrite') setSessionProvider('remote-task', 'new-source');
@@ -43,6 +48,7 @@ describe('hosted provider binding lifecycle', () => {
binding.release();
expect(getSessionProvider('remote-task')).toBe(boundary === 'overwrite' ? 'new-source' : null);
expect(hasSessionProvider('remote-task')).toBe(boundary === 'overwrite');
+ expect(hasHostedSessionModelAccess('remote-task')).toBe(false);
});
});
diff --git a/apps/desktop/src/main/maker-host/anthropic-compat-proxy-host.ts b/apps/desktop/src/main/maker-host/anthropic-compat-proxy-host.ts
index 27922a5358..4268a781cf 100644
--- a/apps/desktop/src/main/maker-host/anthropic-compat-proxy-host.ts
+++ b/apps/desktop/src/main/maker-host/anthropic-compat-proxy-host.ts
@@ -80,10 +80,11 @@ import {
} from './claude-session-route-registry.js';
import { createClaudeGatewayErrorObserver } from './claude-gateway-error-observer.js';
import { shouldApplyExclusiveProviderReroute } from './model-route-guard.js';
-import { getSessionProvider } from './session-provider-store.js';
+import { getSessionProvider, hasHostedSessionModelAccess } from './session-provider-store.js';
import {
GUEST_ROUTE_HEADER,
guestProviderOffersModel,
+ hostedProviderOffersModel,
guestProviderRouteForSession,
guestProviderRouteForToken,
type GuestProviderRoute,
@@ -687,7 +688,8 @@ export function createModelRoutingTransform(): RoutingTransform {
if (piGuest && !piRequestStaysOnGuestProvider(piGuest, piProviderId, registeredPiProviderId)) {
return refuseGuestProviderRoute(403, 'shared_provider_only', 'This request is outside the provider shared with you.');
}
- if (piGuest) {
+ if (piGuest || hasHostedSessionModelAccess(piSessionId)) {
+ const providerId = piGuest?.providerId ?? piProviderId ?? selectedPiProviderId;
// Check the live member grant before native handlers and all other Pi routing branches.
// Google's native API puts the authoritative model in the URL instead of body.model.
const requestModels: string[] = [];
@@ -695,15 +697,18 @@ export function createModelRoutingTransform(): RoutingTransform {
if (typeof body.model === 'string' && body.model) requestModels.push(body.model);
// Subscription forwarders use body.model and rebuild their own URL; a forged Google
// path cannot stand in for a missing/opaque subscription request body.
- if (!isOpenAiSubscriptionProviderId(piGuest.providerId) && !isXaiSubscriptionProviderId(piGuest.providerId)) {
+ if (!isOpenAiSubscriptionProviderId(providerId) && !isXaiSubscriptionProviderId(providerId)) {
const pathname = new URL(ctx.url, 'http://127.0.0.1').pathname;
const pathModel = /\/models\/(.+):(?:streamGenerateContent|generateContent|countTokens)$/.exec(pathname);
if (pathModel) requestModels.push(decodeURIComponent(pathModel[1]));
}
}
- const deniedModel = requestModels.find(model => !guestProviderOffersModel(piGuest.providerId, 'pi', model, piGuest.sessionId));
+ const deniedModel = requestModels.find(model => piGuest
+ ? !guestProviderOffersModel(piGuest.providerId, 'pi', model, piGuest.sessionId)
+ : !hostedProviderOffersModel(piSessionId, providerId, 'pi', model));
if (requestModels.length === 0 || deniedModel !== undefined) {
- return refuseGuestForeignRoute(deniedModel ?? '');
+ return piGuest ? refuseGuestForeignRoute(deniedModel ?? '')
+ : refuseGuestProviderRoute(403, 'remote_model_not_allowed', 'This model is not available for this remote task.');
}
}
if (piSessionId && piProviderId && (isOpenAiSubscriptionProviderId(piProviderId) || isXaiSubscriptionProviderId(piProviderId))) {
@@ -752,6 +757,9 @@ export function createModelRoutingTransform(): RoutingTransform {
if (pendingRoute) return pendingRoute;
const selectedProviderId = sessionId ? getSessionProvider(sessionId) : null;
+ if (!piSessionId && !hostedProviderOffersModel(sessionId, selectedProviderId, 'claude-code', wireModel)) {
+ return refuseGuestProviderRoute(403, 'remote_model_not_allowed', 'This model is not available for this remote task.');
+ }
if (guest && selectedProviderId !== guest.providerId) return refuseGuestForeignRoute(wireModel);
const applyExclusiveReroute = shouldApplyExclusiveProviderReroute(
selectedProviderId,
diff --git a/apps/desktop/src/main/maker-host/codex-proxy-host.ts b/apps/desktop/src/main/maker-host/codex-proxy-host.ts
index 3e898f8411..5d1d58ebf1 100644
--- a/apps/desktop/src/main/maker-host/codex-proxy-host.ts
+++ b/apps/desktop/src/main/maker-host/codex-proxy-host.ts
@@ -122,8 +122,8 @@ import {
rewriteSessionModelIdForRoute,
} from './provider-route.js';
import type { CodexSubagentRouteSnapshot } from './codex-subagent-config.js';
-import { getSessionProvider } from './session-provider-store.js';
-import { guestProviderModelAllowed, guestProviderOffersModel, guestProviderRouteForSession } from './guest-provider-route-store.js';
+import { getSessionProvider, hasHostedSessionModelAccess } from './session-provider-store.js';
+import { guestProviderModelAllowed, guestProviderOffersModel, guestProviderRouteForSession, hostedProviderOffersModel } from './guest-provider-route-store.js';
import { isOpenAiSubscriptionProviderId } from './codex-account-auth.js';
import { composeResponseObservers } from './claude-rate-limit-headers-observer.js';
import { createProviderUpstreamErrorObserver, reportProviderUpstreamError } from './provider-upstream-error-observer.js';
@@ -2815,6 +2815,9 @@ function resolveCodexCustomProviderRoutingDecision(
return codexCustomProviderRouteFailure(403, 'custom_provider_model_mismatch');
}
const wireModel = parsed.pathKind === 'responses' ? requestModel : undefined;
+ if (wireModel && !hostedProviderOffersModel(sessionIdFromHeaders(ctx.headers), route.providerId, 'codex', wireModel)) {
+ return codexCustomProviderRouteFailure(403, 'remote_model_not_allowed');
+ }
return resolveFrozenProviderRouteDecision(
route.providerId,
frozenRouting,
@@ -2974,6 +2977,11 @@ export function createModelRoutingTransform(
const model = subagentRoute?.catalogModel ?? reportedModel;
const explicitProviderId = subagentRoute?.providerId
?? (sessionId ? getSessionProvider(sessionId) : null);
+ const authorizationModel = model === CODEX_AUTO_REVIEW_MODEL && guardianParentThreadIdFromHeaders(ctx.headers) && sessionId
+ ? reviewerModelBySession.get(sessionId) ?? model : model;
+ if (model && !hostedProviderOffersModel(sessionId, explicitProviderId, 'codex', authorizationModel)) {
+ return codexCustomProviderRouteFailure(403, 'remote_model_not_allowed');
+ }
// 推理请求钉在 Claude 订阅上(旧会话 / 子代理快照):本地拒绝,不落任何默认上游。
if (model && explicitProviderId && isClaudeSubscriptionProviderId(explicitProviderId)) {
return claudeSubscriptionCodexRefusalDecision();
@@ -3499,6 +3507,8 @@ async function createCodexProxyHandle(
*/
resolveWebSocketUpstream: ({ headers }) => {
if ((frozenAuthInjection ?? getCodexProxyAuthInjection()) !== 'oauth-bearer') return null;
+ // Hosted owner tasks need HTTP so every model request (and later revocation) reaches the live grant check.
+ if (hasHostedSessionModelAccess(sessionIdFromHeaders(headers))) return null;
const threadId = selectedThreadIdFromHeaders(headers);
const recoveryReason = httpRecoveryReasonByThread.get(threadId);
if (recoveryReason) {
diff --git a/apps/desktop/src/main/maker-host/guest-provider-route-store.ts b/apps/desktop/src/main/maker-host/guest-provider-route-store.ts
index e5d4d5a881..0a256a79ff 100644
--- a/apps/desktop/src/main/maker-host/guest-provider-route-store.ts
+++ b/apps/desktop/src/main/maker-host/guest-provider-route-store.ts
@@ -6,14 +6,14 @@
* - 签发路由令牌。托管会话不在 Maker 的活跃会话表里,Claude Code 的请求经自定义请求头
* 带上令牌,Claude proxy 据此认出这条会话;Codex / Pi 的请求按会话 id 找到登记。
* proxy 对受邀者请求只放行这个供应商、且是它提供的模型;其余一律本地拒绝,不改道。
- * 只对受邀者生效,本机用户自己的任务不经过这里。
+ * 同账号远程任务复用下方的目录模型匹配,通过独立的 owner 登记校验实时授权;本机任务不受限制。
*/
import { randomBytes } from 'node:crypto';
import { findCatalogModel, type AgentKind } from '@cindy/model-providers';
import { getActiveCatalog } from './active-catalog.js';
-import { clearSessionProvider, getSessionProvider, setSessionProvider } from './session-provider-store.js';
+import { clearSessionProvider, getSessionProvider, hasHostedSessionModelAccess, hostedSessionModelAllowed, setSessionProvider } from './session-provider-store.js';
/**
* Claude Code 请求带上的路由令牌请求头。与 maker-core 的 DEVICE_HOSTED_GUEST_ROUTE_HEADER 同值
@@ -92,15 +92,25 @@ function bareModelId(model: string): string {
/** 核对目录与授权时优先匹配请求的窗口档位;单条目的旧 SDK 后缀别名仍兼容。 */
export function guestProviderOffersModel(providerId: string, agent: AgentKind, wireModel: string, sessionId?: string): boolean {
+ return providerOffersModel(providerId, agent, wireModel, sessionId ? bySession.get(sessionId)?.allowsModel : undefined);
+}
+
+/** Same-account remote tasks authorize each root/child request without pinning children to the parent provider. */
+export function hostedProviderOffersModel(sessionId: string | null | undefined, providerId: string | null | undefined, agent: AgentKind, wireModel: string): boolean {
+ if (!sessionId || !hasHostedSessionModelAccess(sessionId)) return true;
+ return !!providerId && providerOffersModel(providerId, agent, wireModel,
+ model => hostedSessionModelAllowed(sessionId, providerId, model));
+}
+
+function providerOffersModel(providerId: string, agent: AgentKind, wireModel: string, allowsModel?: (model: string) => boolean): boolean {
const requested = bareModelId(wireModel);
if (!requested) return false;
const provider = getActiveCatalog().providers.find((candidate) => candidate.id === providerId);
- const binding = sessionId ? bySession.get(sessionId) : undefined;
if (agent === 'pi') {
// Pi native subscriptions send bare wire ids; grants use the catalog's namespaced ids.
// Keep distinct context profiles exact so one profile cannot borrow another's grant.
const model = findCatalogModel(provider, wireModel, agent, { exact: true });
- return Boolean(model && !model.disabled && (!binding?.allowsModel || binding.allowsModel(model.id)));
+ return Boolean(model && !model.disabled && (!allowsModel || allowsModel(model.id)));
}
const profiles = (provider?.models[agent] ?? []).filter(model => bareModelId(model.id) === requested);
const longContext = /\[1m\]$/i.test(wireModel.trim());
@@ -108,7 +118,7 @@ export function guestProviderOffersModel(providerId: string, agent: AgentKind, w
// Select the catalog profile before checking grants or disabled state; neither
// a denied nor a disabled profile may borrow access from its sibling.
return (exactProfiles.length ? exactProfiles : profiles).some((model) => !model.disabled
- && (!binding?.allowsModel || binding.allowsModel(model.id)));
+ && (!allowsModel || allowsModel(model.id)));
}
/** A shared proxy without a task identity cannot bypass an active member's model restrictions. */
diff --git a/apps/desktop/src/main/maker-host/session-provider-store.ts b/apps/desktop/src/main/maker-host/session-provider-store.ts
index d1dee7667c..8041bb67db 100644
--- a/apps/desktop/src/main/maker-host/session-provider-store.ts
+++ b/apps/desktop/src/main/maker-host/session-provider-store.ts
@@ -15,7 +15,7 @@
*/
const bySession = new Map<string, string | null>();
-const hostedBindings = new Map<string, symbol>();
+const hostedBindings = new Map<string, { allowsModel?: (providerId: string, model: string) => boolean }>();
/** Canonical provider id used by runtime routing and every persistence adapter. */
export function normalizeSessionProviderId(
@@ -37,11 +37,15 @@ export function setSessionProvider(sessionId: string, providerId: string | null)
* 每次运行持有独立登记:重连后的新运行、普通写入或账号清理都会令旧登记失效,
* 迟到的换源/回滚/收尾不能覆盖新运行或重新写回已清掉的来源。
*/
-export function bindHostedSessionProvider(sessionId: string, providerId: string): {
+export function bindHostedSessionProvider(
+ sessionId: string,
+ providerId: string,
+ allowsModel?: (providerId: string, model: string) => boolean,
+): {
setProvider(providerId: string): void;
release(): void;
} {
- const binding = Symbol();
+ const binding = { allowsModel };
hostedBindings.set(sessionId, binding);
bySession.set(sessionId, normalizeSessionProviderId(providerId) ?? null);
return {
@@ -56,6 +60,17 @@ export function bindHostedSessionProvider(sessionId: string, providerId: string)
};
}
+/** Only remote owner tasks carry this gate; ordinary local sessions retain their routing behavior. */
+export function hasHostedSessionModelAccess(sessionId: string | null | undefined): boolean {
+ return !!sessionId && !!hostedBindings.get(sessionId)?.allowsModel;
+}
+
+/** Model is the exact catalog identity, resolved from the request's actual provider and wire model. */
+export function hostedSessionModelAllowed(sessionId: string, providerId: string, model: string): boolean {
+ try { return hostedBindings.get(sessionId)?.allowsModel?.(providerId, model) ?? true; }
+ catch { return false; }
+}
+
/**
* 启动派发边界(`prepareStartOptions` 钩子)冻结调用方携带的来源:登记须早于第一次
* send 且不经 DB 往返 —— renderer 那份排在 createSession 之后、落库失败只记日志,
diff --git a/apps/desktop/src/main/remote-agent/__tests__/hostedProviderRouting.test.ts b/apps/desktop/src/main/remote-agent/__tests__/hostedProviderRouting.test.ts
index 89a4c71afb..b4cf9ad864 100644
--- a/apps/desktop/src/main/remote-agent/__tests__/hostedProviderRouting.test.ts
+++ b/apps/desktop/src/main/remote-agent/__tests__/hostedProviderRouting.test.ts
@@ -84,6 +84,7 @@ function setup(hooks: {
requestSessionId?: (input: HostedStartInput) => string;
isOwnerCurrent?: () => boolean;
trust?: 'owner' | 'guest';
+ allowsModel?: (providerId: string, model: string) => boolean;
} = {}) {
const starts: HostedStartInput[] = [];
const routes: unknown[] = [];
@@ -95,7 +96,7 @@ function setup(hooks: {
controllerTrust: () => hooks.trust ?? 'owner',
providerAccess: {
resolve: async (_kind, _model, providerId) => providerId === 'forbidden' ? null : providerId ?? 'fp',
- isAllowed: (providerId) => providerId !== 'forbidden',
+ isAllowed: (providerId, _controller, model) => providerId !== 'forbidden' && (hooks.allowsModel?.(providerId, model ?? '') ?? true),
},
bindOwnerProviderRoute: bindHostedSessionProvider,
bindGuestProviderRoute: async () => ({ routeToken: 'test-guest-route', modelIds: [MODEL], release() {} }),
@@ -169,6 +170,31 @@ async function switchProvider(runId: string, providerId?: string | null) {
}
describe('same-account hosted provider routing', () => {
+ // Unit regression for review 4327641928: real host registration must reach the
+ // proxy before the first request and read live grants. Previous tests only checked
+ // provider selection; minimum is a hosted session allowed one of two catalog models.
+ it('binds live owner model authorization before routing hosted Claude requests', async () => {
+ let allowedModel = MODEL;
+ const sdkSessionId = randomUUID();
+ setup({ requestSessionId: () => sdkSessionId, allowsModel: (_providerId, model) => model === allowedModel });
+ const runId = await open('fp', 'task-1', OWNER, 'claude-code');
+ await waitForEvent(runId, 'started');
+ const request = (model: string) => createModelRoutingTransform()({ model }, {
+ reqId: 1, method: 'POST', url: '/v1/messages', headers: { 'x-claude-code-session-id': sdkSessionId },
+ });
+ const expectDenied = async (model: string) => {
+ const decision = await request(model);
+ let status: number | undefined;
+ await decision?.localHandler?.({ res: { writeHead: (code: number) => { status = code; }, end() {} } } as never);
+ expect(status).toBe(403);
+ };
+ expect(await request(MODEL)).toMatchObject({ upstreamOverride: 'https://fp.example.invalid/anthropic' });
+ await expectDenied(CLAUDE_MODEL);
+ allowedModel = CLAUDE_MODEL;
+ await expectDenied(MODEL);
+ expect(await request(CLAUDE_MODEL)).toMatchObject({ upstreamOverride: 'https://fp.example.invalid/anthropic' });
+ });
+
it.each([CLAUDE_MODEL, MODEL])('routes Claude SDK-ID requests to the selected provider for %s', async (model) => {
const sdkSessionId = randomUUID();
setup({ requestSessionId: () => sdkSessionId });
diff --git a/apps/desktop/src/main/remote-agent/host/runHost.ts b/apps/desktop/src/main/remote-agent/host/runHost.ts
index e3a7dcf2c2..0fc5820ff8 100644
--- a/apps/desktop/src/main/remote-agent/host/runHost.ts
+++ b/apps/desktop/src/main/remote-agent/host/runHost.ts
@@ -199,8 +199,8 @@ export interface RemoteAgentHostDeps {
resolve(kind: RemoteAgentKind, model: string, providerId: string | null | undefined, controller: string): Promise<string | null>;
isAllowed(providerId: string, controller: string, model?: string): boolean;
};
- /** 同账号任务也须在启动前登记已核对开放的来源,不能只把 providerId 传给 Agent。 */
- bindOwnerProviderRoute?(hostSessionId: string, providerId: string): OwnerProviderRouteBinding;
+ /** 同账号任务在启动前登记来源和逐请求的实时模型授权,子代理同样受此约束。 */
+ bindOwnerProviderRoute?(hostSessionId: string, providerId: string, allowsModel?: (providerId: string, model: string) => boolean): OwnerProviderRouteBinding;
/**
* 受邀者任务的出站边界(只对 guest 调用;不提供 = 不接受受邀者)。启动前登记任务用的供应商:本机
* proxy 只让这条任务的请求经这个供应商、用它提供的模型。release 在任务结束时调用。
@@ -1119,7 +1119,10 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
}
guestProvider = { providerId: run.providerId, modelIds: [...binding.modelIds], routeToken: binding.routeToken };
} else if (run.providerId) {
- run.ownerRoute = deps.bindOwnerProviderRoute?.(hostSessionId, run.providerId);
+ run.ownerRoute = deps.bindOwnerProviderRoute?.(hostSessionId, run.providerId, deps.providerAccess
+ ? (providerId, model) => !run.closing && deps.isControllerAuthorized(run.controller)
+ && deps.providerAccess!.isAllowed(providerId, run.controller, model)
+ : undefined);
}
const handle = await deps.startHosted({
kind: run.kind,
diff --git a/docs/product-rules/provider-sharing.md b/docs/product-rules/provider-sharing.md
index f0fe6aaaf8..9a12b31ea2 100644
--- a/docs/product-rules/provider-sharing.md
+++ b/docs/product-rules/provider-sharing.md
@@ -579,7 +579,8 @@ Desktop「设置 → 模型供应商」的左栏(2026-10-08 用户裁决):
模型范围存于提供方电脑,按账号隔离。旧配置默认跟随全部模型;读取损坏配置时拒绝调用,不能恢复为全部开放。
远程目录只提供可用模型;提供方还必须在创建、切换模型、发送下一轮消息及供应商组转发时校验权限,不能信任控制端传来的目录或模型 id。
-已开始的一轮不因修改勾选主动中断,下一轮或切换模型时按最新范围校验;受邀者经本机代理发出的后续模型请求也会重新校验个人范围。
+已开始的一轮不因修改勾选主动中断,下一轮或切换模型时按最新范围校验;同账号远程任务及受邀者经本机代理发出的后续模型请求(含子代理)也按实际供应商与模型复核最新范围。
+同账号子代理可使用已开放的其他供应商,不因父任务的来源而被固定到同一家;受邀者仍只能使用分享的供应商及个人授权范围。
## 13. 后续可选