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.mdnew file mode 100644index 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.tsindex 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: ScheduleTurnExcreated_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.tsindex 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.tsindex 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: stringexport 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.tsindex 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-corimport 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.tsindex 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): MiddlewareHathrow 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): Middlewif (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.tsindex 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.tsindex 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.Formreturn 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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/SqliteSkillimport { 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.tsnew file mode 100644index 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();+ });+ });+});