Skip to content

The open-source agent harness - the runtime layer that turns an LLM into a working agent.

fix: Use ServiceFoundry dual vend-token response: (#706)

Heer Ambavi04531576b62b
diff --git a/.changeset/trueforge-dual-vend-tokens.md b/.changeset/trueforge-dual-vend-tokens.md
new file mode 100644
index 000000000..c1443a447
--- /dev/null
+++ b/.changeset/trueforge-dual-vend-tokens.md
@@ -0,0 +1,5 @@
+---
+'@truefoundry/trueforge': minor
+---
+
+Use ServiceFoundry dual vend-token response: `actorToken` for ServiceFoundry calls and `subjectToken` for gateway (model api_key and MCP invoke).
diff --git a/packages/trueforge/src/truefoundry/TrueFoundryMcpServerStore.ts b/packages/trueforge/src/truefoundry/TrueFoundryMcpServerStore.ts
index fd02feae1..c0d6b86e6 100644
--- a/packages/trueforge/src/truefoundry/TrueFoundryMcpServerStore.ts
+++ b/packages/trueforge/src/truefoundry/TrueFoundryMcpServerStore.ts
@@ -63,7 +63,8 @@ export function resolveAuthorizeRedirectURL(input: { returnTo?: string }): strin
/** Read-only MCP registry for TrueFoundry mode (writes managed elsewhere). */
export class TrueFoundryMcpServerStore<TTransaction = never> implements IMcpServerWithAuthStore<TTransaction> {
readonly #client: TrueFoundryMcpApiClient;
- readonly #resolveAccessToken: ResolveAccessToken;
+ readonly #forServiceFoundry: ResolveAccessToken;
+ readonly #forGateway: ResolveAccessToken;
readonly #subject: RequestSubject;
readonly #perServerHeaders: PerServerMcpHeaders;
#gatewayUrl: string | undefined;
@@ -76,12 +77,14 @@ export class TrueFoundryMcpServerStore<TTransaction = never> implements IMcpServ
logger: Logger;
}) {
this.#client = input.client;
- this.#resolveAccessToken = accessTokenForRequest({
+ const tokens = accessTokenForRequest({
client: input.client,
requestContext: asTrueFoundryRequestContext(input.requestContext),
agent: input.agent,
logger: input.logger,
});
+ this.#forServiceFoundry = tokens.forServiceFoundry;
+ this.#forGateway = tokens.forGateway;
this.#subject = input.requestContext.subject;
this.#perServerHeaders = input.perServerHeaders ?? {};
}
@@ -91,7 +94,7 @@ export class TrueFoundryMcpServerStore<TTransaction = never> implements IMcpServ
const { record, userRef } = input;
const headers = async (): Promise<Record<string, string>> => ({
...withoutAuthorization(this.#perServerHeaders[record.name]),
- Authorization: `Bearer ${await this.#resolveAccessToken()}`,
+ Authorization: `Bearer ${await this.#forGateway()}`,
});
return async () => {
const status = await this.authorize({
@@ -122,7 +125,7 @@ export class TrueFoundryMcpServerStore<TTransaction = never> implements IMcpServ
return [];
}
- const accessToken = await this.#resolveAccessToken();
+ const accessToken = await this.#forServiceFoundry();
const [rows, gatewayUrl] = await Promise.all([
this.#client.listMcpServers({
accessToken,
@@ -135,7 +138,7 @@ export class TrueFoundryMcpServerStore<TTransaction = never> implements IMcpServ
async getServer(input: GetMcpServerInput, transaction?: TTransaction): Promise<McpServerRecord | undefined> {
void transaction;
- const accessToken = await this.#resolveAccessToken();
+ const accessToken = await this.#forServiceFoundry();
const [row, gatewayUrl] = await Promise.all([
this.#client.getMcpServerByName({ accessToken, name: input.name }),
this.#resolveGatewayUrl(),
@@ -200,7 +203,7 @@ export class TrueFoundryMcpServerStore<TTransaction = never> implements IMcpServ
out.set(
record.name,
await this.#client.getMcpAuthStatus({
- accessToken: await this.#resolveAccessToken(),
+ accessToken: await this.#forServiceFoundry(),
mcpServerId: record.id,
subjectId: this.#subject.id,
subjectType: this.#subject.type,
@@ -216,7 +219,7 @@ export class TrueFoundryMcpServerStore<TTransaction = never> implements IMcpServ
throw new McpServerNotFoundError(input.name);
}
return this.#client.getMcpAuthorize({
- accessToken: await this.#resolveAccessToken(),
+ accessToken: await this.#forServiceFoundry(),
mcpServerId: record.id,
redirectURL: resolveAuthorizeRedirectURL({
...(input.returnTo !== undefined ? { returnTo: input.returnTo } : {}),
@@ -231,7 +234,7 @@ export class TrueFoundryMcpServerStore<TTransaction = never> implements IMcpServ
throw new McpServerNotFoundError(input.name);
}
await this.#client.deleteMcpAuth({
- accessToken: await this.#resolveAccessToken(),
+ accessToken: await this.#forServiceFoundry(),
mcpServerId: record.id,
subjectId: this.#subject.id,
subjectType: this.#subject.type,
@@ -241,7 +244,7 @@ export class TrueFoundryMcpServerStore<TTransaction = never> implements IMcpServ
async #resolveGatewayUrl(): Promise<string> {
if (this.#gatewayUrl === undefined) {
- const installations = await this.#client.listGatewayInstallations(await this.#resolveAccessToken());
+ const installations = await this.#client.listGatewayInstallations(await this.#forServiceFoundry());
this.#gatewayUrl = resolveDefaultGatewayUrl(installations);
}
return this.#gatewayUrl;
diff --git a/packages/trueforge/src/truefoundry/TrueFoundryModelProviderStore.ts b/packages/trueforge/src/truefoundry/TrueFoundryModelProviderStore.ts
index 6b308c26f..7738de8fa 100644
--- a/packages/trueforge/src/truefoundry/TrueFoundryModelProviderStore.ts
+++ b/packages/trueforge/src/truefoundry/TrueFoundryModelProviderStore.ts
@@ -19,7 +19,8 @@ import { TrueFoundryServiceFoundryServerClient } from './TrueFoundryServiceFound
export class TrueFoundryModelProviderStore<TTransaction = never> implements IModelProviderStore<TTransaction> {
readonly #client: TrueFoundryServiceFoundryServerClient;
- readonly #resolveAccessToken: ResolveAccessToken;
+ readonly #forServiceFoundry: ResolveAccessToken;
+ readonly #forGateway: ResolveAccessToken;
constructor(input: {
client: TrueFoundryServiceFoundryServerClient;
@@ -28,12 +29,14 @@ export class TrueFoundryModelProviderStore<TTransaction = never> implements IMod
logger: Logger;
}) {
this.#client = input.client;
- this.#resolveAccessToken = accessTokenForRequest({
+ const tokens = accessTokenForRequest({
client: input.client,
requestContext: asTrueFoundryRequestContext(input.requestContext),
agent: input.agent,
logger: input.logger,
});
+ this.#forServiceFoundry = tokens.forServiceFoundry;
+ this.#forGateway = tokens.forGateway;
}
async listProviders(input: ListModelProvidersInput, transaction?: TTransaction): Promise<ModelProviderRecord[]> {
@@ -82,19 +85,19 @@ export class TrueFoundryModelProviderStore<TTransaction = never> implements IMod
tenant_id: string;
filter?: { provider_account_name: string; name: string };
}): Promise<ModelProviderRecord[]> {
- const accessToken = await this.#resolveAccessToken();
+ const [sfyToken, gatewayToken] = await Promise.all([this.#forServiceFoundry(), this.#forGateway()]);
const [integrations, installations] = await Promise.all([
this.#client.listProviderIntegrations({
- accessToken,
+ accessToken: sfyToken,
...(input.filter !== undefined ? { filter: input.filter } : {}),
}),
- this.#client.listGatewayInstallations(accessToken),
+ this.#client.listGatewayInstallations(sfyToken),
]);
const gatewayUrl = resolveDefaultGatewayUrl(installations);
return toRecords({
tenant_id: input.tenant_id,
gatewayUrl,
- accessToken,
+ accessToken: gatewayToken,
models: mapEnabledModels({ integrations }),
});
}
diff --git a/packages/trueforge/src/truefoundry/TrueFoundryServiceFoundryServerClient.ts b/packages/trueforge/src/truefoundry/TrueFoundryServiceFoundryServerClient.ts
index a164b661f..99ed4b4bc 100644
--- a/packages/trueforge/src/truefoundry/TrueFoundryServiceFoundryServerClient.ts
+++ b/packages/trueforge/src/truefoundry/TrueFoundryServiceFoundryServerClient.ts
@@ -85,9 +85,12 @@ const AgentPermissionsSchema = z.record(
export type AgentPermissions = z.infer<typeof AgentPermissionsSchema>;
const VendTokenResponseSchema = z.object({
- token: z.string().min(1),
+ subjectToken: z.string().min(1),
+ actorToken: z.string().min(1),
});
+export type VendedTokens = z.infer<typeof VendTokenResponseSchema>;
+
export interface PutRemoteAgentInput {
accessToken: string;
name: string;
@@ -526,14 +529,15 @@ export class TrueFoundryServiceFoundryServerClient {
}
/**
- * Exchange a TrueFoundry API key for an agent-scoped token.
+ * Exchange a TrueFoundry API key for dual agent-scoped tokens.
+ * `actorToken` is the agent identity (ServiceFoundry); `subjectToken` is user+act (gateway).
* Authenticated with the server API key, not the user bearer.
*/
async vendToken(input: {
subject: { id: string; type: string; display_name: string };
agentId: string;
tenantName: string;
- }): Promise<string> {
+ }): Promise<VendedTokens> {
const payload = await this.#requestJson({
url: this.#url(VEND_TOKEN_PATH),
accessToken: this.#apiKey,
@@ -556,7 +560,7 @@ export class TrueFoundryServiceFoundryServerClient {
cause: parsed.error,
});
}
- return parsed.data.token;
+ return parsed.data;
}
#parseListResponse(payload: unknown): ListResponse {
diff --git a/packages/trueforge/src/truefoundry/accessToken.ts b/packages/trueforge/src/truefoundry/accessToken.ts
index a32931755..974ccbd0f 100644
--- a/packages/trueforge/src/truefoundry/accessToken.ts
+++ b/packages/trueforge/src/truefoundry/accessToken.ts
@@ -3,7 +3,7 @@ import type { Logger } from 'winston';
import type { RequestContext } from '../auth/identity';
import type { AgentRecord } from '../db/agentStore';
import { requireTrueFoundryAgentExternalId } from './errors';
-import type { TrueFoundryServiceFoundryServerClient } from './TrueFoundryServiceFoundryServerClient';
+import type { TrueFoundryServiceFoundryServerClient, VendedTokens } from './TrueFoundryServiceFoundryServerClient';
/**
* Token for one TrueFoundry call. Resolved on first use and reused for later calls on the same
@@ -11,6 +11,16 @@ import type { TrueFoundryServiceFoundryServerClient } from './TrueFoundryService
*/
export type ResolveAccessToken = () => Promise<string>;
+/**
+ * Destination-specific tokens for a TrueFoundry request.
+ * ServiceFoundry uses the agent identity (`actorToken`); gateway uses user+act (`subjectToken`).
+ * Without a saved agent, both resolve to the caller's credential.
+ */
+export interface DestinationTokens {
+ forServiceFoundry: ResolveAccessToken;
+ forGateway: ResolveAccessToken;
+}
+
type AgentTokenVendor = Pick<TrueFoundryServiceFoundryServerClient, 'vendToken'>;
/** Per-request map of saved-agent vends; not exported so only this module can read it. */
@@ -21,7 +31,7 @@ const accessTokenCache: unique symbol = Symbol('truefoundryAccessTokenCache');
* lifetime of one HTTP request; a later request gets a new context and vends again.
*/
export type TrueFoundryRequestContext = RequestContext & {
- readonly [accessTokenCache]: Map<string, ResolveAccessToken>;
+ readonly [accessTokenCache]: Map<string, DestinationTokens>;
};
export function createTrueFoundryRequestContext(base: RequestContext): TrueFoundryRequestContext {
@@ -39,20 +49,27 @@ export function asTrueFoundryRequestContext(context: RequestContext): TrueFoundr
return context;
}
+function destinationTokensFromCaller(context: RequestContext): DestinationTokens {
+ const resolve = callerAccessToken(context);
+ return { forServiceFoundry: resolve, forGateway: resolve };
+}
+
/**
- * Token scoped to a saved agent, for work the agent does on the caller's behalf.
+ * Dual tokens scoped to a saved agent, for work the agent does on the caller's behalf.
* Throws 500 up front when the agent was never registered with TrueFoundry.
+ * Vends once; ServiceFoundry gets `actorToken`, gateway gets `subjectToken`.
*/
export function agentAccessToken(input: {
client: AgentTokenVendor;
requestContext: Pick<RequestContext, 'tenant_id' | 'subject'>;
agent: AgentRecord;
logger: Pick<Logger, 'info'>;
-}): ResolveAccessToken {
+}): DestinationTokens {
const { client, requestContext: context } = input;
const agentId = requireTrueFoundryAgentExternalId(input.agent);
- let pending: Promise<string> | undefined;
- return () => {
+ let pending: Promise<VendedTokens> | undefined;
+
+ const vended = (): Promise<VendedTokens> => {
if (pending === undefined) {
input.logger.info('Exchanging user context for agent access token', {
subject: context.subject.id,
@@ -67,6 +84,11 @@ export function agentAccessToken(input: {
}
return pending;
};
+
+ return {
+ forServiceFoundry: async () => (await vended()).actorToken,
+ forGateway: async () => (await vended()).subjectToken,
+ };
}
/** Token of whoever made the request. */
@@ -81,17 +103,17 @@ export function callerAccessToken(context: RequestContext): ResolveAccessToken {
}
/**
- * Token for a TrueFoundry request, optionally scoped to the saved agent executing a turn.
- * Saved-agent callables are stored on this request's context so model, MCP, and skill stores share one vend.
+ * Destination tokens for a TrueFoundry request, optionally scoped to the saved agent executing a turn.
+ * Saved-agent callables are stored on this request's context so model and MCP stores share one vend.
*/
export function accessTokenForRequest(input: {
client: AgentTokenVendor;
requestContext: TrueFoundryRequestContext;
agent: AgentRecord | undefined;
logger: Pick<Logger, 'info'>;
-}): ResolveAccessToken {
+}): DestinationTokens {
if (input.agent === undefined) {
- return callerAccessToken(input.requestContext);
+ return destinationTokensFromCaller(input.requestContext);
}
const agentId = requireTrueFoundryAgentExternalId(input.agent);
const cache = input.requestContext[accessTokenCache];
@@ -99,12 +121,12 @@ export function accessTokenForRequest(input: {
if (existing !== undefined) {
return existing;
}
- const resolveAgentAccessToken = agentAccessToken({
+ const tokens = agentAccessToken({
client: input.client,
requestContext: input.requestContext,
agent: input.agent,
logger: input.logger,
});
- cache.set(agentId, resolveAgentAccessToken);
- return resolveAgentAccessToken;
+ cache.set(agentId, tokens);
+ return tokens;
}
diff --git a/packages/trueforge/tests/unit/truefoundry/TrueFoundryMcpServerStore.test.ts b/packages/trueforge/tests/unit/truefoundry/TrueFoundryMcpServerStore.test.ts
index 733532622..95c7c9586 100644
--- a/packages/trueforge/tests/unit/truefoundry/TrueFoundryMcpServerStore.test.ts
+++ b/packages/trueforge/tests/unit/truefoundry/TrueFoundryMcpServerStore.test.ts
@@ -1,5 +1,7 @@
+import { AgentSpecSchema } from '@truefoundry/trueforge-core/agent-session';
import { createLogger } from 'winston';
import { getPublicBaseUrl } from '../../../src/config';
+import type { AgentRecord } from '../../../src/db/agentStore';
import { McpServerNotFoundError, type McpServerRecord } from '../../../src/db/mcpServerStore';
import { createTrueFoundryRequestContext } from '../../../src/truefoundry/accessToken';
import { MCP_PROXY_BASE_URL_TEMPLATE } from '../../../src/truefoundry/mapSfyMcpServers';
@@ -11,6 +13,19 @@ import {
const TENANT = 'default';
const ACCESS_TOKEN = 'caller-access-token';
+const SUBJECT_TOKEN = 'subject-token';
+const ACTOR_TOKEN = 'actor-token';
+
+const AGENT: AgentRecord = {
+ id: 'agent-1',
+ tenant_id: TENANT,
+ name: 'named',
+ manifest: AgentSpecSchema.parse({ model: { name: 'p/m' } }),
+ external_id: 'ext-agent',
+ created_by_subject: { subject_id: 'user-1', subject_type: 'user', subject_display_name: 'User' },
+ created_at: '2026-01-01T00:00:00.000Z',
+ updated_at: '2026-01-01T00:00:00.000Z',
+};
const SFY_ROW = {
id: 'mcp-id-1',
@@ -43,6 +58,7 @@ function createStore(input?: {
accessToken?: string;
client?: MockClient;
subject?: { id: string; type: string; display_name: string };
+ agent?: AgentRecord;
}) {
const client = input?.client ?? createMockClient();
client.getMcpServerByName.mockResolvedValue(SFY_ROW);
@@ -51,6 +67,9 @@ function createStore(input?: {
client.getMcpAuthorize.mockResolvedValue({ status: 'authenticated' });
client.getMcpAuthStatus.mockResolvedValue({ status: 'authenticated' });
client.deleteMcpAuth.mockResolvedValue(undefined);
+ if (input?.agent !== undefined) {
+ client.vendToken.mockResolvedValue({ subjectToken: SUBJECT_TOKEN, actorToken: ACTOR_TOKEN });
+ }
const store = new TrueFoundryMcpServerStore({
client,
requestContext: createTrueFoundryRequestContext({
@@ -59,7 +78,7 @@ function createStore(input?: {
roles: [],
user_credential: input?.accessToken ?? ACCESS_TOKEN,
}),
- agent: undefined,
+ agent: input?.agent,
logger: createLogger({ silent: true }),
});
return { store, client };
@@ -272,6 +291,17 @@ describe('TrueFoundryMcpServerStore', () => {
});
});
+ it('uses actorToken for SFY authorize and subjectToken for gateway Bearer with a saved agent', async () => {
+ const { store, client } = createStore({ agent: AGENT });
+ await expect(invoke(store)).resolves.toEqual({
+ headers: { Authorization: `Bearer ${SUBJECT_TOKEN}` },
+ });
+ expect(client.getMcpAuthorize).toHaveBeenCalledWith(expect.objectContaining({ accessToken: ACTOR_TOKEN }));
+ expect(client.getMcpServerByName).toHaveBeenCalledWith(expect.objectContaining({ accessToken: ACTOR_TOKEN }));
+ expect(client.listGatewayInstallations).toHaveBeenCalledWith(ACTOR_TOKEN);
+ expect(client.vendToken).toHaveBeenCalledTimes(1);
+ });
+
it('throws 422 when auth_required lacks authorization_url', async () => {
const { store, client } = createStore();
client.getMcpAuthorize.mockResolvedValue({ status: 'auth_required' });
diff --git a/packages/trueforge/tests/unit/truefoundry/TrueFoundryModelProviderStore.test.ts b/packages/trueforge/tests/unit/truefoundry/TrueFoundryModelProviderStore.test.ts
new file mode 100644
index 000000000..652c42056
--- /dev/null
+++ b/packages/trueforge/tests/unit/truefoundry/TrueFoundryModelProviderStore.test.ts
@@ -0,0 +1,63 @@
+import { AgentSpecSchema } from '@truefoundry/trueforge-core/agent-session';
+import { createLogger } from 'winston';
+import type { AgentRecord } from '../../../src/db/agentStore';
+import { createTrueFoundryRequestContext } from '../../../src/truefoundry/accessToken';
+import { TrueFoundryModelProviderStore } from '../../../src/truefoundry/TrueFoundryModelProviderStore';
+import type { TrueFoundryServiceFoundryServerClient } from '../../../src/truefoundry/TrueFoundryServiceFoundryServerClient';
+
+const TENANT = 'acme';
+const SUBJECT_TOKEN = 'subject-token';
+const ACTOR_TOKEN = 'actor-token';
+
+const AGENT: AgentRecord = {
+ id: 'agent-1',
+ tenant_id: TENANT,
+ name: 'named',
+ manifest: AgentSpecSchema.parse({ model: { name: 'p/m' } }),
+ external_id: 'ext-agent',
+ created_by_subject: { subject_id: 'user-1', subject_type: 'user', subject_display_name: 'User' },
+ created_at: '2026-01-01T00:00:00.000Z',
+ updated_at: '2026-01-01T00:00:00.000Z',
+};
+
+describe('TrueFoundryModelProviderStore dual tokens', () => {
+ it('uses actorToken for SFY list calls and subjectToken as gateway api_key', async () => {
+ const client = {
+ listProviderIntegrations: jest.fn().mockResolvedValue([
+ {
+ name: 'gpt-4',
+ manifest: { model_types: ['chat'] },
+ providerAccount: { name: 'openai-main' },
+ },
+ ]),
+ listGatewayInstallations: jest
+ .fn()
+ .mockResolvedValue([{ isDefault: true, manifest: { url: 'https://gateway.example' } }]),
+ vendToken: jest.fn().mockResolvedValue({ subjectToken: SUBJECT_TOKEN, actorToken: ACTOR_TOKEN }),
+ } as unknown as TrueFoundryServiceFoundryServerClient;
+
+ const store = new TrueFoundryModelProviderStore({
+ client,
+ requestContext: createTrueFoundryRequestContext({
+ tenant_id: TENANT,
+ subject: { id: 'user-1', type: 'user', display_name: 'User' },
+ roles: [],
+ user_credential: 'caller-token',
+ }),
+ agent: AGENT,
+ logger: createLogger({ silent: true }),
+ });
+
+ const providers = await store.listProviders({ tenant_id: TENANT });
+
+ expect(client.listProviderIntegrations).toHaveBeenCalledWith(expect.objectContaining({ accessToken: ACTOR_TOKEN }));
+ expect(client.listGatewayInstallations).toHaveBeenCalledWith(ACTOR_TOKEN);
+ expect(client.vendToken).toHaveBeenCalledTimes(1);
+ expect(providers).toHaveLength(1);
+ expect(providers[0]?.manifest).toMatchObject({
+ type: 'truefoundry',
+ base_url: 'https://gateway.example',
+ auth: { api_key: SUBJECT_TOKEN },
+ });
+ });
+});
diff --git a/packages/trueforge/tests/unit/truefoundry/accessToken.test.ts b/packages/trueforge/tests/unit/truefoundry/accessToken.test.ts
index 5e1b0d981..bddd67fc3 100644
--- a/packages/trueforge/tests/unit/truefoundry/accessToken.test.ts
+++ b/packages/trueforge/tests/unit/truefoundry/accessToken.test.ts
@@ -18,6 +18,8 @@ const CONTEXT: RequestContext = {
};
const LOGGER = { info: jest.fn() };
+const VENDED = { subjectToken: 'subject-token', actorToken: 'actor-token' };
+
const AGENT: AgentRecord = {
id: 'agent-1',
tenant_id: 'acme',
@@ -42,13 +44,13 @@ describe('callerAccessToken', () => {
});
describe('agentAccessToken', () => {
- it('vends a token scoped to the agent, naming the caller as the subject', async () => {
- const client = { vendToken: jest.fn().mockResolvedValue('agent-token') };
+ it('vends dual tokens scoped to the agent, naming the caller as the subject', async () => {
+ const client = { vendToken: jest.fn().mockResolvedValue(VENDED) };
const logger = { info: jest.fn() };
- await expect(agentAccessToken({ client, requestContext: CONTEXT, agent: AGENT, logger })()).resolves.toBe(
- 'agent-token',
- );
+ const tokens = agentAccessToken({ client, requestContext: CONTEXT, agent: AGENT, logger });
+ await expect(tokens.forServiceFoundry()).resolves.toBe('actor-token');
+ await expect(tokens.forGateway()).resolves.toBe('subject-token');
expect(logger.info).toHaveBeenCalledWith('Exchanging user context for agent access token', {
subject: 'user-1',
agentId: 'ext-agent',
@@ -60,23 +62,24 @@ describe('agentAccessToken', () => {
});
});
- it('vends once and reuses the token for later calls', async () => {
- const client = { vendToken: jest.fn().mockResolvedValue('agent-token') };
- const resolve = agentAccessToken({ client, requestContext: CONTEXT, agent: AGENT, logger: LOGGER });
+ it('vends once and reuses both tokens for later calls', async () => {
+ const client = { vendToken: jest.fn().mockResolvedValue(VENDED) };
+ const tokens = agentAccessToken({ client, requestContext: CONTEXT, agent: AGENT, logger: LOGGER });
- await expect(Promise.all([resolve(), resolve()])).resolves.toEqual(['agent-token', 'agent-token']);
- await expect(resolve()).resolves.toBe('agent-token');
+ await expect(
+ Promise.all([tokens.forServiceFoundry(), tokens.forGateway(), tokens.forServiceFoundry()]),
+ ).resolves.toEqual(['actor-token', 'subject-token', 'actor-token']);
expect(client.vendToken).toHaveBeenCalledTimes(1);
});
it('vends again after a failed exchange', async () => {
const client = {
- vendToken: jest.fn().mockRejectedValueOnce(new Error('vend failed')).mockResolvedValue('agent-token'),
+ vendToken: jest.fn().mockRejectedValueOnce(new Error('vend failed')).mockResolvedValue(VENDED),
};
- const resolve = agentAccessToken({ client, requestContext: CONTEXT, agent: AGENT, logger: LOGGER });
+ const tokens = agentAccessToken({ client, requestContext: CONTEXT, agent: AGENT, logger: LOGGER });
- await expect(resolve()).rejects.toThrow('vend failed');
- await expect(resolve()).resolves.toBe('agent-token');
+ await expect(tokens.forServiceFoundry()).rejects.toThrow('vend failed');
+ await expect(tokens.forGateway()).resolves.toBe('subject-token');
expect(client.vendToken).toHaveBeenCalledTimes(2);
});
@@ -102,55 +105,59 @@ describe('asTrueFoundryRequestContext', () => {
});
describe('accessTokenForRequest', () => {
- it('uses the caller token without an agent', async () => {
+ it('uses the caller token for both destinations without an agent', async () => {
const client = { vendToken: jest.fn() };
const context = createTrueFoundryRequestContext(CONTEXT);
- await expect(
- accessTokenForRequest({ client, requestContext: context, agent: undefined, logger: LOGGER })(),
- ).resolves.toBe('caller-token');
+ const tokens = accessTokenForRequest({
+ client,
+ requestContext: context,
+ agent: undefined,
+ logger: LOGGER,
+ });
+ await expect(tokens.forServiceFoundry()).resolves.toBe('caller-token');
+ await expect(tokens.forGateway()).resolves.toBe('caller-token');
+ expect(tokens.forServiceFoundry).toBe(tokens.forGateway);
expect(client.vendToken).not.toHaveBeenCalled();
});
- it('uses a vended token with an agent', async () => {
- const client = { vendToken: jest.fn().mockResolvedValue('agent-token') };
+ it('uses actorToken for ServiceFoundry and subjectToken for gateway with an agent', async () => {
+ const client = { vendToken: jest.fn().mockResolvedValue(VENDED) };
const context = createTrueFoundryRequestContext(CONTEXT);
- await expect(
- accessTokenForRequest({ client, requestContext: context, agent: AGENT, logger: LOGGER })(),
- ).resolves.toBe('agent-token');
+ const tokens = accessTokenForRequest({ client, requestContext: context, agent: AGENT, logger: LOGGER });
+ await expect(tokens.forServiceFoundry()).resolves.toBe('actor-token');
+ await expect(tokens.forGateway()).resolves.toBe('subject-token');
expect(client.vendToken).toHaveBeenCalledTimes(1);
});
- it('shares one vend across model, MCP, and skill stores on the same request', async () => {
- const client = { vendToken: jest.fn().mockResolvedValue('agent-token') };
+ it('shares one vend across model and MCP stores on the same request', async () => {
+ const client = { vendToken: jest.fn().mockResolvedValue(VENDED) };
const context = createTrueFoundryRequestContext(CONTEXT);
const model = accessTokenForRequest({ client, requestContext: context, agent: AGENT, logger: LOGGER });
const mcp = accessTokenForRequest({ client, requestContext: context, agent: AGENT, logger: LOGGER });
- const skill = accessTokenForRequest({ client, requestContext: context, agent: AGENT, logger: LOGGER });
expect(model).toBe(mcp);
- expect(mcp).toBe(skill);
- await expect(Promise.all([model(), mcp(), skill()])).resolves.toEqual([
- 'agent-token',
- 'agent-token',
- 'agent-token',
+ await expect(Promise.all([model.forServiceFoundry(), mcp.forGateway(), model.forGateway()])).resolves.toEqual([
+ 'actor-token',
+ 'subject-token',
+ 'subject-token',
]);
expect(client.vendToken).toHaveBeenCalledTimes(1);
});
it('vends again on a later request for the same user and agent', async () => {
- const client = { vendToken: jest.fn().mockResolvedValue('agent-token') };
+ const client = { vendToken: jest.fn().mockResolvedValue(VENDED) };
const firstRequest = createTrueFoundryRequestContext(CONTEXT);
const secondRequest = createTrueFoundryRequestContext(CONTEXT);
await expect(
- accessTokenForRequest({ client, requestContext: firstRequest, agent: AGENT, logger: LOGGER })(),
- ).resolves.toBe('agent-token');
+ accessTokenForRequest({ client, requestContext: firstRequest, agent: AGENT, logger: LOGGER }).forServiceFoundry(),
+ ).resolves.toBe('actor-token');
await expect(
- accessTokenForRequest({ client, requestContext: secondRequest, agent: AGENT, logger: LOGGER })(),
- ).resolves.toBe('agent-token');
+ accessTokenForRequest({ client, requestContext: secondRequest, agent: AGENT, logger: LOGGER }).forGateway(),
+ ).resolves.toBe('subject-token');
expect(client.vendToken).toHaveBeenCalledTimes(2);
});
});
diff --git a/packages/trueforge/tests/unit/truefoundry/perServerMcpHeaders.test.ts b/packages/trueforge/tests/unit/truefoundry/perServerMcpHeaders.test.ts
index 021e221fb..2266ee017 100644
--- a/packages/trueforge/tests/unit/truefoundry/perServerMcpHeaders.test.ts
+++ b/packages/trueforge/tests/unit/truefoundry/perServerMcpHeaders.test.ts
@@ -24,7 +24,7 @@ function unusedClient(): TrueFoundryMcpApiClient {
getMcpAuthorize: async () => ({ status: 'authenticated' }),
getMcpAuthStatus: unused,
deleteMcpAuth: unused,
- vendToken: () => Promise.resolve('caller-token'),
+ vendToken: () => Promise.resolve({ subjectToken: 'caller-token', actorToken: 'caller-token' }),
};
}