Skip to content

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

feat: add logger context and record, session_id, turn_id, request_id, and tenant_id (#1084)

Raman Tehlan3b2405ee4ec6
diff --git a/.changeset/log-correlation-ids.md b/.changeset/log-correlation-ids.md
new file mode 100644
index 000000000..ef2322150
--- /dev/null
+++ b/.changeset/log-correlation-ids.md
@@ -0,0 +1,5 @@
+---
+'@truefoundry/trueforge': patch
+---
+
+Add tenant, request, session, and turn ids to server and controller logs so a failure can be filtered to one request or turn. Log lines no longer include the package version.
diff --git a/packages/trueforge/src/apis/schedules.ts b/packages/trueforge/src/apis/schedules.ts
index ff70519db..b790267b1 100644
--- a/packages/trueforge/src/apis/schedules.ts
+++ b/packages/trueforge/src/apis/schedules.ts
@@ -43,6 +43,7 @@ import {
import type { ISkillStore } from '../db/skillStore';
import type { WithTransaction } from '../db/transaction';
import type { IWebSearchProviderStore } from '../db/webSearchProviderStore';
+import { updateLogContext } from '../logger';
import {
createScheduleRoute,
createScheduleRunRoute,
@@ -208,6 +209,7 @@ export function createScheduleExecutionRouter<TTransaction>(deps: ScheduleTurnEx
created_by_subject: item.schedule.created_by_subject,
}),
);
+ updateLogContext({ tenant_id: item.schedule.tenant_id });
await startScheduleRunOnRequest({ c, item, deps });
} catch (error) {
if (
diff --git a/packages/trueforge/src/apis/sessions.ts b/packages/trueforge/src/apis/sessions.ts
index 067423241..5890b7a48 100644
--- a/packages/trueforge/src/apis/sessions.ts
+++ b/packages/trueforge/src/apis/sessions.ts
@@ -39,6 +39,7 @@ import type { ISandboxEnvironmentStore } from '../db/sandboxEnvironmentStore';
import type { ISandboxProviderStore } from '../db/sandboxProviderStore';
import type { ISkillStore } from '../db/skillStore';
import type { IWebSearchProviderStore } from '../db/webSearchProviderStore';
+import { updateLogContext } from '../logger';
import {
cancelSessionRoute,
createSessionRoute,
@@ -161,6 +162,8 @@ export async function cancelSessionTurn(
): Promise<void> {
const { turnId, reason = CancellationReason.ClientCancelled } = input;
const sessionId = deps.session.session_id;
+ // Cancel is POST /sessions/{session_id}/cancel — path middleware has session_id only.
+ updateLogContext({ turn_id: turnId });
const turn = await deps.sessionStore.getTurn({
session_id: sessionId,
@@ -193,8 +196,7 @@ export async function cancelSessionTurn(
}
} catch (error) {
const fields = {
- sessionId,
- turnId,
+ turn_id: turnId,
owner,
...extractErrorLogFields(error),
};
@@ -369,6 +371,7 @@ export function createSessionsRouter(deps: SessionsRouterDeps) {
const createSessionHandler: RouteHandler<typeof createSessionRoute> = async c => {
const body = c.req.valid('json');
const sessionId = newId();
+ updateLogContext({ session_id: sessionId });
const requestContext = deps.resolveRequestContext(c);
if (isSessionAgentNameRef(body.agent)) {
diff --git a/packages/trueforge/src/apis/turns.ts b/packages/trueforge/src/apis/turns.ts
index 2ed7110f2..af77bd6e1 100644
--- a/packages/trueforge/src/apis/turns.ts
+++ b/packages/trueforge/src/apis/turns.ts
@@ -46,6 +46,7 @@ import type { ISandboxProviderStore } from '../db/sandboxProviderStore';
import type { ISkillStore } from '../db/skillStore';
import type { TurnMetadata } from '../db/turnMetadata';
import type { IWebSearchProviderStore } from '../db/webSearchProviderStore';
+import { currentLogContext, updateLogContext } from '../logger';
import {
createAndExecuteTurnRoute,
createTurnEventRoute,
@@ -387,13 +388,11 @@ export function turnStreamId(tenantId: string, sessionId: string, turnId: string
export async function drainTurnEvents(input: {
trackedStream: AsyncIterable<TurnStreamingEvent>;
turnEventStream: EventSubscription<TurnStreamingEvent>;
- sessionId: string;
- turnId: string;
maxExecutionTimer: NodeJS.Timeout;
logger: Logger;
onEvent?: (event: TurnStreamingEvent, sequenceNumber: number) => Promise<void>;
}): Promise<void> {
- const { trackedStream, turnEventStream, sessionId, turnId, maxExecutionTimer, logger, onEvent } = input;
+ const { trackedStream, turnEventStream, maxExecutionTimer, logger, onEvent } = input;
try {
for await (const event of trackedStream) {
// Dual-write before any client sink so subscribers can resume after disconnect.
@@ -404,17 +403,9 @@ export async function drainTurnEvents(input: {
}
} catch (error) {
if (error instanceof SessionStoreNotFoundError) {
- logger.warn('Turn stream ended after session/turn was removed', {
- sessionId,
- turnId,
- ...extractErrorLogFields(error),
- });
+ logger.warn('Turn stream ended after session/turn was removed', extractErrorLogFields(error));
} else {
- logger.error('Unexpected error in turn event drain', {
- sessionId,
- turnId,
- ...extractErrorLogFields(error),
- });
+ logger.error('Unexpected error in turn event drain', extractErrorLogFields(error));
}
} finally {
clearTimeout(maxExecutionTimer);
@@ -425,8 +416,6 @@ export async function drainTurnEvents(input: {
export interface TurnEventDrainInput {
trackedStream: AsyncIterable<TurnStreamingEvent>;
turnEventStream: EventSubscription<TurnStreamingEvent>;
- sessionId: string;
- turnId: string;
maxExecutionTimer: NodeJS.Timeout;
logger: Logger;
}
@@ -443,12 +432,18 @@ export async function beginTurnExecution(
assertGatewayMetadataRequestHeaders(requestHeaders);
const sessionId = session.session_id;
const turnId = newId();
+ const tenantId = session.tenant_id;
+ // Before the resolver, so model, MCP, and sandbox lines on this chain carry the ids.
+ updateLogContext({
+ tenant_id: tenantId,
+ session_id: sessionId,
+ turn_id: turnId,
+ });
const sessionAgent = session.record.agent;
const abortController = new AbortController();
- const tenant_id = session.tenant_id;
const webSearchProvider = await resolveWebSearchProvider({
- tenant_id,
+ tenant_id: tenantId,
store: deps.webSearchProviderStore,
});
const resolver = createTurnResolver({
@@ -500,15 +495,13 @@ export async function beginTurnExecution(
});
// Held for the whole turn; the stream's sequence counter dies with it.
- const turnEventStream = deps.eventSubscriptions.get(turnStreamId(tenant_id, sessionId, turn.id));
+ const turnEventStream = deps.eventSubscriptions.get(turnStreamId(tenantId, sessionId, turn.id));
return {
turn,
drainInput: {
trackedStream,
turnEventStream,
- sessionId,
- turnId: turn.id,
maxExecutionTimer,
logger: deps.logger,
},
@@ -733,8 +726,6 @@ export function createTurnsRouter(deps: TurnsRouterDeps) {
}
deps.logger.error('Sandbox file download failed', {
...extractErrorLogFields(error),
- sessionId,
- turnId,
sandboxId,
path,
});
@@ -861,15 +852,22 @@ export function createTurnsRouter(deps: TurnsRouterDeps) {
}
// Stream: same engine; a hung SSE write is timed out so drain/dual-write continue.
- const { drainInput } = await beginTurnExecution(turnParams);
+ const { drainInput, turn } = await beginTurnExecution(turnParams);
+ // Hono maps client disconnect to stream.abort() (body cancel / AbortSignal)
+ // outside request ALS, so capture ids here and pass them on the disconnect line.
+ const disconnectLogContext = {
+ ...currentLogContext(),
+ session_id: sessionId,
+ turn_id: turn.id,
+ };
let shouldWriteToSSEStream = true;
return streamSSE(c, async stream => {
stream.onAbort(() => {
shouldWriteToSSEStream = false;
- deps.logger.info('Create-turn SSE client disconnected, continuing drain without writing', {
- sessionId,
- turnId: drainInput.turnId,
- });
+ deps.logger.info(
+ 'Create-turn SSE client disconnected, continuing drain without writing',
+ disconnectLogContext,
+ );
});
await drainTurnEvents({
...drainInput,
@@ -952,8 +950,6 @@ export function createTurnsRouter(deps: TurnsRouterDeps) {
const timeoutMs = configuration.TURN_SUBSCRIBE_TIMEOUT_MS;
const timeoutHandler = setTimeout(() => {
deps.logger.info('Subscribe turn stream server-side timeout reached, closing stream', {
- sessionId,
- turnId,
afterSequenceNumber,
timeoutMs,
});
diff --git a/packages/trueforge/src/app.ts b/packages/trueforge/src/app.ts
index f0c4650f9..b66bbab55 100644
--- a/packages/trueforge/src/app.ts
+++ b/packages/trueforge/src/app.ts
@@ -7,6 +7,7 @@ import type { RedisClient, RequestReplyRouter } from '@truefoundry/trueforge-cor
import type { Context, ErrorHandler, MiddlewareHandler } from 'hono';
import { bodyLimit } from 'hono/body-limit';
import { HTTPException } from 'hono/http-exception';
+import { randomUUID } from 'node:crypto';
import type { Configuration } from 'openid-client';
import type { Logger } from 'winston';
import { createAgentsRouter } from './apis/agents';
@@ -52,6 +53,7 @@ import type { WithTransaction } from './db/transaction';
import type { IWebSearchProviderStore } from './db/webSearchProviderStore';
import { createHttpMetrics } from './http/prometheus';
import { createClientCertificateMiddleware } from './http/tls';
+import { runWithLogContext, updateLogContext, type LogContext } from './logger';
import type { IOAuthTokenStore } from './mcp/auth/types';
import { PACKAGE_VERSION } from './packageVersion';
import { OPENAPI_DOCUMENT_TAGS } from './routes/openapiTags';
@@ -62,6 +64,48 @@ import { zodErrorResponse, zodValidationHook } from './zodErrorResponse';
const BEARER_AUTH_SCHEME = 'BearerAuth';
+const REQUEST_ID_HEADER = 'x-request-id';
+
+/** Single token. Rejects spaces, quotes, and newlines so a caller cannot break a JSON log line. */
+const SAFE_REQUEST_ID = /^[A-Za-z0-9._:-]{1,200}$/;
+
+function requestIdFromHeader(raw: string | undefined): string {
+ if (raw !== undefined && SAFE_REQUEST_ID.test(raw)) {
+ return raw;
+ }
+ return randomUUID();
+}
+
+/**
+ * Opens a log context for the request and echoes `x-request-id`.
+ * Registered first so the access log and error handler run inside it.
+ */
+export function createRequestLogContextMiddleware(): MiddlewareHandler {
+ return async (c, next) => {
+ const request_id = requestIdFromHeader(c.req.header(REQUEST_ID_HEADER));
+ c.header(REQUEST_ID_HEADER, request_id);
+ await runWithLogContext({ request_id }, async () => {
+ await next();
+ });
+ };
+}
+
+/** Stamp session and turn ids from the matched route params. Skips `/api/internal/sessions/...`. */
+export function createSessionPathLogContextMiddleware(): MiddlewareHandler {
+ return async (c, next) => {
+ const session_id = c.req.param('session_id');
+ const turn_id = c.req.param('turn_id');
+ const fields: LogContext = {
+ ...(session_id === undefined ? {} : { session_id }),
+ ...(turn_id === undefined ? {} : { turn_id }),
+ };
+ if (session_id !== undefined || turn_id !== undefined) {
+ updateLogContext(fields);
+ }
+ await next();
+ };
+}
+
function withAuth(router: OpenAPIHono, middleware: MiddlewareHandler): OpenAPIHono {
const shell = new OpenAPIHono();
shell.use('*', middleware);
@@ -305,6 +349,9 @@ export function createServerApp<TTransaction>(deps: ServerDeps<TTransaction>) {
};
const httpMetrics = createHttpMetrics();
+ app.use('*', createRequestLogContextMiddleware());
+ app.use('/api/v1/sessions/:session_id/*', createSessionPathLogContextMiddleware());
+ app.use('/api/v1/sessions/:session_id/turns/:turn_id/*', createSessionPathLogContextMiddleware());
// Health, the scrape endpoint, and static files sit outside /api, so they never enter this middleware.
app.use('/api/*', httpMetrics.middleware);
if (configuration.ACCESS_LOGS) {
diff --git a/packages/trueforge/src/auth/middleware.ts b/packages/trueforge/src/auth/middleware.ts
index 803e9a7cd..6fa973c3f 100644
--- a/packages/trueforge/src/auth/middleware.ts
+++ b/packages/trueforge/src/auth/middleware.ts
@@ -4,6 +4,7 @@ import type { Context, MiddlewareHandler } from 'hono';
import { HTTPException } from 'hono/http-exception';
import { jwtVerify } from 'jose';
+import { updateLogContext } from '../logger';
import type { Authenticator } from './authenticator';
import { toRequestContext, type IdTokenClaims } from './claims';
import { hasAdminRole, type RequestContext } from './identity';
@@ -19,6 +20,7 @@ export function createAuthMiddleware(authenticator: Authenticator): MiddlewareHa
throw new HTTPException(401, { message: 'Authentication required' });
}
c.set('request_context', requestContext);
+ updateLogContext({ tenant_id: requestContext.tenant_id });
return next();
};
}
@@ -29,6 +31,7 @@ export function createAdminAuthMiddleware(authenticator: Authenticator): Middlew
if (requestContext === undefined) {
throw new HTTPException(401, { message: 'Authentication required' });
}
+ updateLogContext({ tenant_id: requestContext.tenant_id });
if (!hasAdminRole(requestContext)) {
throw new HTTPException(403, { message: 'Admin access required' });
}
diff --git a/packages/trueforge/src/controller-main.ts b/packages/trueforge/src/controller-main.ts
index 9abe045a4..cc18273d7 100644
--- a/packages/trueforge/src/controller-main.ts
+++ b/packages/trueforge/src/controller-main.ts
@@ -17,14 +17,12 @@ import { runController } from './controller';
import { createDb } from './db/postgres/client';
import { PostgresScheduleStore } from './db/postgres/schedule-store/PostgresScheduleStore';
import { createControllerLogger } from './logger';
-import { PACKAGE_VERSION } from './packageVersion';
import { initSentry } from './sentry';
try {
const logger = createControllerLogger({
level: configuration.LOG_LEVEL,
standalone: configuration.STANDALONE,
- version: PACKAGE_VERSION,
});
await initSentry(configuration, logger, { tags: { component: 'controller' } });
diff --git a/packages/trueforge/src/logger.ts b/packages/trueforge/src/logger.ts
index 2a4229350..f6c366e09 100644
--- a/packages/trueforge/src/logger.ts
+++ b/packages/trueforge/src/logger.ts
@@ -1,12 +1,77 @@
/**
* Process logger: human-readable lines in standalone mode, JSON otherwise.
- * JSON output carries `version` and `component` ('server' | 'controller') in defaultMeta
- * so hosted aggregators can tell the two processes apart; both are omitted from the
+ * JSON output carries `component` ('server' | 'controller') in defaultMeta
+ * so hosted aggregators can tell the two processes apart; it is omitted from the
* human-readable standalone format to keep local logs terse.
+ * In-flight work stamps `tenant_id`, `request_id`, `session_id`, and `turn_id` when known.
*/
+import { AsyncLocalStorage } from 'node:async_hooks';
import winston, { type Logger } from 'winston';
-const STANDALONE_META_SKIP = new Set(['level', 'message', 'timestamp', 'version', 'component', 'stack', 'splat']);
+const STANDALONE_META_SKIP = new Set(['level', 'message', 'timestamp', 'component', 'stack', 'splat']);
+
+/** Ids copied onto each Winston line while the matching work is in progress. Absent keys are omitted. */
+export interface LogContext {
+ tenant_id?: string;
+ request_id?: string;
+ session_id?: string;
+ turn_id?: string;
+}
+
+const LOG_CONTEXT_KEYS: (keyof LogContext)[] = ['tenant_id', 'request_id', 'session_id', 'turn_id'];
+
+const logContextStorage = new AsyncLocalStorage<LogContext>();
+
+function assignDefined(target: LogContext, fields: LogContext): void {
+ for (const key of LOG_CONTEXT_KEYS) {
+ const value = fields[key];
+ if (value !== undefined) {
+ target[key] = value;
+ }
+ }
+}
+
+/** Run `fn` with `fields` overlaid on the current ids. Nested calls keep parent ids they do not replace. */
+export function runWithLogContext<T>(fields: LogContext, fn: () => T): T {
+ const parent = logContextStorage.getStore();
+ const next: LogContext = parent === undefined ? {} : { ...parent };
+ assignDefined(next, fields);
+ return logContextStorage.run(next, fn);
+}
+
+/** Merge `fields` into the current context. No-op outside {@link runWithLogContext}. */
+export function updateLogContext(fields: LogContext): void {
+ const store = logContextStorage.getStore();
+ if (store === undefined) {
+ return;
+ }
+ assignDefined(store, fields);
+}
+
+/** Current ids, or `undefined` when no request or turn context is active. */
+export function currentLogContext(): LogContext | undefined {
+ return logContextStorage.getStore();
+}
+
+/** Fill missing id keys from the active context. A field passed on the log call wins. */
+function logContextFormat(): winston.Logform.Format {
+ return winston.format(info => {
+ const store = logContextStorage.getStore();
+ if (store === undefined) {
+ return info;
+ }
+ for (const key of LOG_CONTEXT_KEYS) {
+ if (info[key] !== undefined) {
+ continue;
+ }
+ const value = store[key];
+ if (value !== undefined) {
+ info[key] = value;
+ }
+ }
+ return info;
+ })();
+}
export function shouldColorize(): boolean {
const noColor = process.env['NO_COLOR'];
@@ -42,6 +107,7 @@ function standaloneFormat(color: boolean): winston.Logform.Format {
const parts: winston.Logform.Format[] = [
winston.format.timestamp({ format: 'HH:mm:ss' }),
winston.format.errors({ stack: true }),
+ logContextFormat(),
];
if (color) {
parts.push(winston.format.colorize({ level: true }));
@@ -60,6 +126,7 @@ function jsonFormat(): winston.Logform.Format {
return winston.format.combine(
winston.format.timestamp(),
winston.format.errors({ stack: true }),
+ logContextFormat(),
winston.format.json(),
);
}
@@ -71,24 +138,19 @@ function serverLogFormat(options: { standalone: boolean }): winston.Logform.Form
return jsonFormat();
}
-function createLogger(options: {
- level: string;
- standalone: boolean;
- version: string;
- component: 'server' | 'controller';
-}): Logger {
+function createLogger(options: { level: string; standalone: boolean; component: 'server' | 'controller' }): Logger {
return winston.createLogger({
level: options.level,
- defaultMeta: { version: options.version, component: options.component },
+ defaultMeta: { component: options.component },
format: serverLogFormat({ standalone: options.standalone }),
transports: [new winston.transports.Console()],
});
}
-export function createServerLogger(options: { level: string; standalone: boolean; version: string }): Logger {
+export function createServerLogger(options: { level: string; standalone: boolean }): Logger {
return createLogger({ ...options, component: 'server' });
}
-export function createControllerLogger(options: { level: string; standalone: boolean; version: string }): Logger {
+export function createControllerLogger(options: { level: string; standalone: boolean }): Logger {
return createLogger({ ...options, component: 'controller' });
}
diff --git a/packages/trueforge/src/main.ts b/packages/trueforge/src/main.ts
index 955f2b6c3..609848285 100644
--- a/packages/trueforge/src/main.ts
+++ b/packages/trueforge/src/main.ts
@@ -799,7 +799,6 @@ try {
const logger = createServerLogger({
level: configuration.LOG_LEVEL,
standalone: configuration.STANDALONE,
- version: PACKAGE_VERSION,
});
await initSentry(configuration, logger, { tags: { component: 'server' } });
diff --git a/packages/trueforge/src/packageVersion.ts b/packages/trueforge/src/packageVersion.ts
index dc6ac2aae..a7a282220 100644
--- a/packages/trueforge/src/packageVersion.ts
+++ b/packages/trueforge/src/packageVersion.ts
@@ -1,5 +1,5 @@
/**
- * Package version for logs, the OpenAPI document, and the CLI.
+ * Package version for the OpenAPI document and the CLI.
*
* Read from `package.json` next to this module's package root — the same
* `src/` vs `dist/` layout as `config.ts` (`import.meta` → parent).
diff --git a/packages/trueforge/tests/unit/apis/sessions.test.ts b/packages/trueforge/tests/unit/apis/sessions.test.ts
index ddc8ef3db..a6dc57ae3 100644
--- a/packages/trueforge/tests/unit/apis/sessions.test.ts
+++ b/packages/trueforge/tests/unit/apis/sessions.test.ts
@@ -217,7 +217,7 @@ describe('cancelSessionTurn', () => {
expect(session.freezeTurn).toHaveBeenCalled();
expect(logger.warn).toHaveBeenCalledWith(
'Failed to reach owning executor over Redis; freezing the running turn',
- expect.objectContaining({ sessionId: SESSION_ID, turnId, owner: REMOTE_EXECUTOR }),
+ expect.objectContaining({ turn_id: turnId, owner: REMOTE_EXECUTOR }),
);
});
@@ -243,7 +243,7 @@ describe('cancelSessionTurn', () => {
expect(session.freezeTurn).toHaveBeenCalled();
expect(logger.warn).toHaveBeenCalledWith(
'Timed out waiting for owning executor to cancel; freezing the running turn',
- expect.objectContaining({ sessionId: SESSION_ID, turnId, owner: REMOTE_EXECUTOR }),
+ expect.objectContaining({ turn_id: turnId, owner: REMOTE_EXECUTOR }),
);
});
@@ -270,8 +270,7 @@ describe('cancelSessionTurn', () => {
expect(logger.warn).toHaveBeenCalledWith(
'Failed to reach owning executor over Redis; freezing the running turn',
expect.objectContaining({
- sessionId: SESSION_ID,
- turnId,
+ turn_id: turnId,
owner: REMOTE_EXECUTOR,
error: 'Redis connection closed',
}),
diff --git a/packages/trueforge/tests/unit/apis/turns.test.ts b/packages/trueforge/tests/unit/apis/turns.test.ts
index 65d707cf0..961cededf 100644
--- a/packages/trueforge/tests/unit/apis/turns.test.ts
+++ b/packages/trueforge/tests/unit/apis/turns.test.ts
@@ -24,6 +24,7 @@ import { SqliteSkillStore } from '../../../src/db/sqlite/skill-store/SqliteSkill
import { SqliteOAuthTokenStore } from '../../../src/db/sqlite/token-store/SqliteOAuthTokenStore';
import type { Database } from '../../../src/db/sqlite/types';
import { SqliteWebSearchProviderStore } from '../../../src/db/sqlite/web-search-provider-store/SqliteWebSearchProviderStore';
+import { runWithLogContext } from '../../../src/logger';
import { ActiveTurnRegistry } from '../../../src/runtime/activeTurns';
import { EventSubscriptionRegistry } from '../../../src/runtime/event-subscription/index.js';
@@ -541,6 +542,147 @@ describe('turns', () => {
});
});
+ describe('create turn streaming disconnect', () => {
+ it('logs session_id and turn_id on SSE abort even without async log context', async () => {
+ const infoCalls: Array<{ message: unknown; meta: unknown }> = [];
+ const logger = createLogger({ silent: true });
+ logger.info = ((message: unknown, meta?: unknown) => {
+ infoCalls.push({ message, meta });
+ return logger;
+ }) as typeof logger.info;
+
+ const db = createSqliteDb(':memory:');
+ await migrateSqliteToLatest(db);
+ const modelProviderStore = new SqliteModelProviderStore(db);
+ await modelProviderStore.upsertProvider({
+ tenant_id: 'default',
+ name: 'test-provider',
+ manifest: {
+ type: 'custom',
+ name: 'test-provider',
+ base_url: 'https://llm.test.example.com/v1',
+ auth: { api_key: 'sk-test' },
+ models: [
+ {
+ model_id: 'test-model',
+ name: 'test-model',
+ properties: { context_length: 128000, max_output_tokens: 4096 },
+ },
+ ],
+ },
+ });
+
+ let releaseRest: (() => void) | undefined;
+ const restParked = new Promise<void>(resolve => {
+ releaseRest = resolve;
+ });
+
+ const sessions = {
+ get: () =>
+ Promise.resolve({
+ session_id: 's1',
+ tenant_id: STANDALONE_REQUEST_CONTEXT.tenant_id,
+ spec: AgentSpecSchema.parse({ model: { name: 'test-provider/test-model' } }),
+ record: {
+ last_turn_id: null,
+ created_by_subject: {
+ subject_id: STANDALONE_REQUEST_CONTEXT.subject.id,
+ subject_type: STANDALONE_REQUEST_CONTEXT.subject.type,
+ subject_display_name: STANDALONE_REQUEST_CONTEXT.subject.display_name,
+ },
+ agent: {
+ type: 'inline',
+ spec: AgentSpecSchema.parse({ model: { name: 'test-provider/test-model' } }),
+ },
+ },
+ createTurn: () =>
+ Promise.resolve({
+ id: 'turn-sse-disconnect',
+ record: {
+ turn_id: 'turn-sse-disconnect',
+ session_id: 's1',
+ previous_turn_id: null,
+ input: [],
+ state: { status: 'running' },
+ created_at: new Date('2026-01-01T00:00:00.000Z'),
+ },
+ stream: async function* stream() {
+ yield {
+ type: 'turn.created',
+ id: 'evt_created',
+ turn_id: 'turn-sse-disconnect',
+ previous_turn_id: null,
+ state: { status: 'running' },
+ created_at: '2026-01-01T00:00:00.000Z',
+ thread_id: null,
+ };
+ await restParked;
+ },
+ }),
+ }),
+ } as unknown as Sessions;
+
+ const tokenStore = new SqliteOAuthTokenStore(db);
+ const app = new OpenAPIHono();
+ app.route(
+ '/',
+ createTurnsRouter({
+ sessions,
+ sessionStore: new SqliteSessionStore(db),
+ activeTurns: new ActiveTurnRegistry(),
+ resolveModelProviderStore: () => modelProviderStore,
+ resolveMcpServerStore: () => mcpServerStoreWithAuth(db, tokenStore),
+ resolveAgentStore: () => new SqliteAgentStore(db),
+ resolveTurnSkillsStore: () => new SqliteSkillStore(db),
+ eventSubscriptions: new EventSubscriptionRegistry<TurnStreamingEvent>(undefined),
+ resolveSandboxProviderStore: () => new SqliteSandboxProviderStore(db),
+ sandboxEnvironmentStore: new SqliteSandboxEnvironmentStore(db),
+ resolveWebSearchProviderStore: () => new SqliteWebSearchProviderStore(db),
+ logger,
+ resolveRequestContext: () => STANDALONE_REQUEST_CONTEXT,
+ authorizer: new TrueForgeAuthorizer(),
+ }),
+ );
+
+ const response = await runWithLogContext({ request_id: 'req-sse-disconnect' }, () =>
+ app.request('/s1/turns', {
+ method: 'POST',
+ headers: { 'content-type': 'application/json' },
+ body: JSON.stringify({ stream: true }),
+ }),
+ );
+ expect(response.status).toBe(200);
+
+ // Client disconnect cancels the response body; Hono maps that to stream.abort().
+ // Cancel outside ALS so the log cannot rely on ambient context.
+ await response.body?.cancel();
+
+ const disconnectDeadline = Date.now() + 2000;
+ let disconnect: (typeof infoCalls)[number] | undefined;
+ while (Date.now() < disconnectDeadline) {
+ disconnect = infoCalls.find(
+ call =>
+ typeof call.message === 'string' &&
+ call.message.includes('Create-turn SSE client disconnected, continuing drain without writing'),
+ );
+ if (disconnect !== undefined) {
+ break;
+ }
+ await new Promise<void>(resolve => setImmediate(resolve));
+ }
+
+ expect(disconnect?.meta).toEqual(
+ expect.objectContaining({
+ request_id: 'req-sse-disconnect',
+ session_id: 's1',
+ turn_id: 'turn-sse-disconnect',
+ }),
+ );
+
+ releaseRest?.();
+ });
+ });
+
describe('turn SSE after session deletion', () => {
it('warns when the stream ends because the session/turn was removed', async () => {
const warnings: unknown[] = [];
diff --git a/packages/trueforge/tests/unit/logger.test.ts b/packages/trueforge/tests/unit/logger.test.ts
new file mode 100644
index 000000000..ffb93efca
--- /dev/null
+++ b/packages/trueforge/tests/unit/logger.test.ts
@@ -0,0 +1,36 @@
+import { currentLogContext, runWithLogContext } from '../../src/logger';
+
+describe('log context AsyncLocalStorage', () => {
+ it('is empty when an AbortSignal listener runs after the request store exits', async () => {
+ let signal: AbortSignal | undefined;
+ const snapshot = await runWithLogContext(
+ { request_id: 'req-1', session_id: 'sess-1', turn_id: 'turn-1', tenant_id: 'ten-1' },
+ () => {
+ const controller = new AbortController();
+ signal = controller.signal;
+ return { controller, fields: { ...currentLogContext() } };
+ },
+ );
+
+ expect(currentLogContext()).toBeUndefined();
+ expect(snapshot.fields).toEqual({
+ request_id: 'req-1',
+ session_id: 'sess-1',
+ turn_id: 'turn-1',
+ tenant_id: 'ten-1',
+ });
+
+ await new Promise<void>(resolve => {
+ signal?.addEventListener(
+ 'abort',
+ () => {
+ // Hono stream.onAbort is driven by the request AbortSignal the same way.
+ expect(currentLogContext()).toBeUndefined();
+ resolve();
+ },
+ { once: true },
+ );
+ snapshot.controller.abort();
+ });
+ });
+});