@roj-ai/sdk 0.1.33 → 0.1.35

package/src/core/agents/agent.ts

@@ -51,6 +51,7 @@ import type { Logger } from '../../lib/logger/logger.js'
 import type { SessionContext } from '../sessions/context.js'
 import type { SessionStore } from '../sessions/session-store.js'
 import type { SessionState } from '../sessions/state.js'
+import { resolveAgentOverrides } from '../sessions/state.js'
 import type { SessionEnvironment, ToolExecutor } from '../tools/index.js'
 import type { AgentContext } from './context.js'
 import { sanitizeLLMResponse } from './response-sanitizer.js'
@@ -200,6 +201,22 @@ export class Agent {
 		return this.store.getAgentState(this.id)
 	}
 
+	/**
+	 * Model for the next inference: the session override if one is set, else the
+	 * model from the preset definition.
+	 *
+	 * Resolved per inference rather than frozen at construction so that changing
+	 * the override applies to agents that are already running. Applying it in
+	 * `Session.getAgentConfig()` instead would only reach agents created after the
+	 * change, and catching up the rest would mean rebuilding live Agent instances
+	 * mid-turn — abort controllers, debounce timers and mailbox state included.
+	 */
+	private resolveModel(): ModelId {
+		const definitionName = this.state?.definitionName
+		if (definitionName === undefined) return this.config.model
+		return resolveAgentOverrides(this.store.getState(), definitionName).model ?? this.config.model
+	}
+
 	// ============================================================================
 	// Public API
 	// ============================================================================
@@ -449,7 +466,7 @@ export class Agent {
 		const cachedMessages = applyCacheBreakpoint(messages, extraMessages.length, this.config.cacheTtl, agentState.preamble.length)
 
 		const request: InferenceRequest = {
-			model: this.config.model,
+			model: this.resolveModel(),
 			systemPrompt: this.buildSystemPrompt(),
 			messages: cachedMessages,
 			tools: this.tools.size > 0 ? [...this.tools.values()] : undefined,
@@ -628,7 +645,7 @@ export class Agent {
 
 		// 5. LLM inference (with retry)
 		const request: InferenceRequest = {
-			model: this.config.model,
+			model: this.resolveModel(),
 			systemPrompt: this.buildSystemPrompt(),
 			messages: cachedMessages,
 			tools: this.tools.size > 0 ? [...this.tools.values()] : undefined,

package/src/core/preset/index.ts

@@ -9,3 +9,6 @@ export { createPreset, validatePreset } from './config.js'
 // Re-export from preset-builder
 export type { CreateOrchestratorInput, DefineAgentInput } from './preset-builder.js'
 export { createOrchestrator, defineAgent } from './preset-builder.js'
+
+// Re-export from overrides
+export { knownDefinitionNames, unknownOverrideTargets } from './overrides.js'

package/src/core/preset/overrides.ts

@@ -0,0 +1,24 @@
+/**
+ * Validation of session overrides against the preset they target.
+ *
+ * Overrides are keyed by agent definition name, which makes a typo silent: the
+ * entry simply never matches and the agent quietly keeps the preset's model.
+ * Every entry point that accepts an override patch rejects unknown names instead.
+ */
+
+import { COMMUNICATOR_ROLE, ORCHESTRATOR_ROLE } from '~/core/agents/agent-roles.js'
+import type { SessionOverridesPatch } from '~/core/sessions/state.js'
+import type { PresetDefinition } from './config.js'
+
+/** Every definition name an override may target, in preset order. */
+export const knownDefinitionNames = (preset: PresetDefinition): string[] => [
+	ORCHESTRATOR_ROLE,
+	...(preset.communicator ? [COMMUNICATOR_ROLE] : []),
+	...preset.agents.map(agent => agent.name),
+]
+
+/** Names in the patch that the preset does not define. Empty when the patch is valid. */
+export const unknownOverrideTargets = (preset: PresetDefinition, patch: SessionOverridesPatch): string[] => {
+	const known = new Set(knownDefinitionNames(preset))
+	return Object.keys(patch.agents ?? {}).filter(name => !known.has(name))
+}

package/src/core/sessions/session-manager.ts

@@ -21,9 +21,10 @@ import type { LLMLogger } from '~/core/llm/logger.js'
 import type { LLMProvider } from '~/core/llm/provider.js'
 import type { CallerContext, ConfiguredPlugin, ManagerMethodContext, PluginDefinition } from '~/core/plugins/plugin-builder.js'
 import type { Preset } from '~/core/preset/index.js'
+import { knownDefinitionNames, unknownOverrideTargets } from '~/core/preset/overrides.js'
 import type { SessionId } from '~/core/sessions/schema.js'
 import { generateSessionId } from '~/core/sessions/schema.js'
-import type { SessionCreatedEvent } from '~/core/sessions/state.js'
+import type { SessionCreatedEvent, SessionOverridesPatch } from '~/core/sessions/state.js'
 import { checkRecoveryNeeded, isSessionCreatedEvent, reconstructSessionState, sessionEvents } from '~/core/sessions/state.js'
 import type { ToolExecutor } from '~/core/tools'
 import { FileLogger } from '~/lib/logger/file.js'
@@ -34,6 +35,7 @@ import type { Result } from '~/lib/utils/result.js'
 import { Err, Ok } from '~/lib/utils/result.js'
 import type { SpawnableAgentInfo } from '~/plugins/agents/index.js'
 import { getAgentUnconsumedMailbox, selectMailboxState } from '~/plugins/mailbox/query.js'
+import type { ServicePidRegistry } from '~/plugins/services/pid-registry.js'
 import type { PortPool } from '~/plugins/services/port-pool.js'
 import type { ServiceConfig } from '~/plugins/services/schema.js'
 import { selectSessionStats, type SessionStatsState } from '~/plugins/session-stats/index.js'
@@ -77,6 +79,7 @@ export interface SessionManagerOptions {
 	preprocessorRegistry?: PreprocessorRegistry
 	llmLogger?: LLMLogger
 	portPool?: PortPool
+	pidRegistry?: ServicePidRegistry
 	/** Host-environment adapters (filesystem, process). */
 	platform: Platform
 	systemPlugins?: readonly PluginDefinition<string, any, any, any, any>[]
@@ -108,6 +111,7 @@ export class SessionManager {
 	private readonly preprocessorRegistry?: PreprocessorRegistry
 	private readonly llmLogger?: LLMLogger
 	private readonly portPool?: PortPool
+	private readonly pidRegistry?: ServicePidRegistry
 	private readonly platform: Platform
 	private readonly systemPlugins: readonly PluginDefinition<string, any, any, any, any>[]
 
@@ -124,6 +128,7 @@ export class SessionManager {
 		this.preprocessorRegistry = options.preprocessorRegistry
 		this.llmLogger = options.llmLogger
 		this.portPool = options.portPool
+		this.pidRegistry = options.pidRegistry
 		this.platform = options.platform
 		this.systemPlugins = options.systemPlugins ?? []
 		this.managerMethods = this.collectManagerMethods()
@@ -139,13 +144,22 @@ export class SessionManager {
 	 */
 	async createSession(
 		presetId: string,
-		options?: { workspaceDir?: string; sessionId?: string },
+		options?: { workspaceDir?: string; sessionId?: string; overrides?: SessionOverridesPatch },
 	): Promise<Result<Session, DomainError>> {
 		const preset = this.presets.get(presetId)
 		if (!preset) {
 			return Err(PresetErrors.notFound(presetId))
 		}
 
+		if (options?.overrides) {
+			const unknown = unknownOverrideTargets(preset, options.overrides)
+			if (unknown.length > 0) {
+				return Err(ValidationErrors.invalid(
+					`Unknown agent definitions in overrides: ${unknown.join(', ')}. Preset '${presetId}' defines: ${knownDefinitionNames(preset).join(', ')}`,
+				))
+			}
+		}
+
 		const sessionId = options?.sessionId ? (options.sessionId as any) : generateSessionId()
 		// First orchestrator gets seq 1
 		const orchestratorId = generateAgentId(ORCHESTRATOR_ROLE, 1)
@@ -171,6 +185,15 @@ export class SessionManager {
 					...(workspaceDir ? { workspaceDir } : {}),
 				}),
 			),
+		]
+
+		// Seeded through the same event a runtime change uses, so there is one code
+		// path and a forked/replayed session reconstructs the overrides for free.
+		if (options?.overrides) {
+			events.push(withSessionId(sessionId, sessionEvents.create('session_overrides_set', options.overrides)))
+		}
+
+		events.push(
 			withSessionId(
 				sessionId,
 				agentEvents.create('agent_spawned', {
@@ -179,7 +202,7 @@ export class SessionManager {
 					parentId: null,
 				}),
 			),
-		]
+		)
 
 		// Spawn communicator if configured
 		const hasCommunicator = !!preset.communicator
@@ -774,7 +797,7 @@ export class SessionManager {
 			}
 		}
 		if (servicesByType.size > 0 && this.portPool) {
-			configs.set('services', { services: [...servicesByType.values()], portPool: this.portPool })
+			configs.set('services', { services: [...servicesByType.values()], portPool: this.portPool, pidRegistry: this.pidRegistry })
 		}
 
 		return configs

package/src/core/sessions/session-overrides.integration.test.ts

@@ -0,0 +1,210 @@
+import { describe, expect, it } from 'bun:test'
+import { ORCHESTRATOR_ROLE } from '~/core/agents/agent-roles.js'
+import { MockLLMProvider } from '~/core/llm/mock.js'
+import { ModelId } from '~/core/llm/schema.js'
+import { createTestPreset, TestHarness } from '~/testing/index.js'
+
+const LUNA = ModelId('openai/gpt-5.6-luna')
+const KIMI = ModelId('moonshotai/kimi-k3')
+
+/** Models the mock provider was actually asked for, in call order. */
+const modelsUsed = (llmProvider: MockLLMProvider): string[] => llmProvider.getCallHistory().map(request => String(request.model))
+
+const newHarness = () =>
+	new TestHarness({
+		presets: [createTestPreset({ agents: [{ name: 'worker', system: 'worker' }] })],
+		llmProvider: MockLLMProvider.withFixedResponse({ content: 'ok', toolCalls: [] }),
+	})
+
+describe('session overrides', () => {
+	it('uses the preset model when no override is set', async () => {
+		const harness = newHarness()
+		const session = await harness.createSession('test')
+
+		await session.sendAndWaitForIdle('hello')
+
+		expect(modelsUsed(harness.llmProvider)).toEqual(['mock'])
+
+		await harness.shutdown()
+	})
+
+	it('applies an override seeded at session creation', async () => {
+		const harness = newHarness()
+		const session = await harness.createSession('test', {
+			overrides: { agents: { [ORCHESTRATOR_ROLE]: { model: LUNA } } },
+		})
+
+		await session.sendAndWaitForIdle('hello')
+
+		expect(modelsUsed(harness.llmProvider)).toEqual([String(LUNA)])
+
+		await harness.shutdown()
+	})
+
+	// The point of resolving the model per inference instead of freezing it on the
+	// Agent at construction: this agent is already built and has already run a turn.
+	it('applies an override set at runtime to an already-running agent', async () => {
+		const harness = newHarness()
+		const session = await harness.createSession('test')
+
+		await session.sendAndWaitForIdle('before')
+		await session.setOverrides({ agents: { [ORCHESTRATOR_ROLE]: { model: LUNA } } })
+		await session.sendAndWaitForIdle('after')
+
+		expect(modelsUsed(harness.llmProvider)).toEqual(['mock', String(LUNA)])
+
+		await harness.shutdown()
+	})
+
+	it('reverts to the preset model when an override is cleared with null', async () => {
+		const harness = newHarness()
+		const session = await harness.createSession('test', {
+			overrides: { agents: { [ORCHESTRATOR_ROLE]: { model: LUNA } } },
+		})
+
+		await session.sendAndWaitForIdle('before')
+		await session.setOverrides({ agents: { [ORCHESTRATOR_ROLE]: null } })
+		await session.sendAndWaitForIdle('after')
+
+		expect(modelsUsed(harness.llmProvider)).toEqual([String(LUNA), 'mock'])
+
+		await harness.shutdown()
+	})
+
+	it('falls back to defaults for an agent with no entry of its own', async () => {
+		const harness = newHarness()
+		const session = await harness.createSession('test', { overrides: { defaults: { model: KIMI } } })
+
+		await session.sendAndWaitForIdle('hello')
+
+		expect(modelsUsed(harness.llmProvider)).toEqual([String(KIMI)])
+
+		await harness.shutdown()
+	})
+
+	it('lets a per-agent entry win over defaults', async () => {
+		const harness = newHarness()
+		const session = await harness.createSession('test', {
+			overrides: { defaults: { model: KIMI }, agents: { [ORCHESTRATOR_ROLE]: { model: LUNA } } },
+		})
+
+		await session.sendAndWaitForIdle('hello')
+
+		expect(modelsUsed(harness.llmProvider)).toEqual([String(LUNA)])
+
+		await harness.shutdown()
+	})
+
+	it('leaves defaults alone when a patch only touches agents', async () => {
+		const harness = newHarness()
+		const session = await harness.createSession('test', { overrides: { defaults: { model: KIMI } } })
+
+		await session.setOverrides({ agents: { worker: { model: LUNA } } })
+		await session.sendAndWaitForIdle('hello')
+
+		// The orchestrator still resolves through the untouched defaults.
+		expect(modelsUsed(harness.llmProvider)).toEqual([String(KIMI)])
+
+		await harness.shutdown()
+	})
+
+	it('rejects an override targeting an agent the preset does not define', async () => {
+		const harness = newHarness()
+
+		const result = await harness.createSessionResult('test', {
+			overrides: { agents: { 'no-such-agent': { model: LUNA } } },
+		})
+
+		expect(result.ok).toBe(false)
+		if (!result.ok) {
+			expect(result.error.message).toContain('no-such-agent')
+		}
+
+		await harness.shutdown()
+	})
+
+	// The RPC surface the worker actually calls.
+	describe('sessions.setOverrides', () => {
+		it('sets the override and echoes back the resolved state', async () => {
+			const harness = newHarness()
+			const session = await harness.createSession('test')
+
+			const result = await harness.sessionManager.callManagerMethod('sessions.setOverrides', {
+				sessionId: String(session.sessionId),
+				overrides: { agents: { worker: { model: LUNA } }, defaults: { model: KIMI } },
+			})
+
+			expect(result.ok).toBe(true)
+			if (result.ok) {
+				expect(result.value).toEqual({
+					agents: { worker: { model: LUNA } },
+					defaults: { model: KIMI },
+				})
+			}
+
+			await harness.shutdown()
+		})
+
+		it('rejects an unknown agent name and names what the preset defines', async () => {
+			const harness = newHarness()
+			const session = await harness.createSession('test')
+
+			const result = await harness.sessionManager.callManagerMethod('sessions.setOverrides', {
+				sessionId: String(session.sessionId),
+				overrides: { agents: { wrker: { model: LUNA } } },
+			})
+
+			expect(result.ok).toBe(false)
+			if (!result.ok) {
+				expect(result.error.message).toContain('wrker')
+				expect(result.error.message).toContain('worker')
+			}
+
+			await harness.shutdown()
+		})
+
+		it('reports the effective overrides back through sessions.get', async () => {
+			const harness = newHarness()
+			const session = await harness.createSession('test', {
+				overrides: { agents: { [ORCHESTRATOR_ROLE]: { model: LUNA } } },
+			})
+
+			const result = await harness.sessionManager.callPluginMethod(
+				session.sessionId,
+				'sessions.get',
+				{ sessionId: String(session.sessionId) },
+			)
+
+			expect(result.ok).toBe(true)
+			if (result.ok) {
+				expect(result.value).toMatchObject({
+					overrides: { agents: { [ORCHESTRATOR_ROLE]: { model: LUNA } } },
+				})
+			}
+
+			await harness.shutdown()
+		})
+	})
+
+	// Overrides are state like any other, so they must survive a replay rather than
+	// living only on the in-memory Session that happened to accept the patch.
+	it('reconstructs overrides when the session is reopened from the event store', async () => {
+		const harness = newHarness()
+		const session = await harness.createSession('test')
+		await session.setOverrides({ agents: { [ORCHESTRATOR_ROLE]: { model: LUNA } } })
+		await harness.shutdown()
+
+		const restarted = new TestHarness({
+			presets: [createTestPreset({ agents: [{ name: 'worker', system: 'worker' }] })],
+			llmProvider: MockLLMProvider.withFixedResponse({ content: 'ok', toolCalls: [] }),
+			eventStore: harness.eventStore,
+		})
+		const reopened = await restarted.openSession(session.sessionId)
+
+		await reopened.sendAndWaitForIdle('hello')
+
+		expect(modelsUsed(restarted.llmProvider)).toEqual([String(LUNA)])
+
+		await restarted.shutdown()
+	})
+})

package/src/core/sessions/session.ts

@@ -22,7 +22,7 @@ import type { AgentPluginConfig, BaseSessionHookContext, CallerContext, Configur
 import { AGENT_CALLER, DEFAULT_CALLER, buildPluginDeps, type PluginNotification } from '~/core/plugins/plugin-builder.js'
 import type { Preset } from '~/core/preset/index.js'
 import type { SessionId } from '~/core/sessions/schema.js'
-import type { SessionState } from '~/core/sessions/state.js'
+import type { SessionOverridesPatch, SessionState } from '~/core/sessions/state.js'
 import { getEntryAgentId, getNextAgentSeq, sessionEvents } from '~/core/sessions/state.js'
 import type { Logger } from '~/lib/logger/logger.js'
 import type { Platform } from '~/platform/index.js'
@@ -214,6 +214,24 @@ export class Session {
 		return Ok(undefined)
 	}
 
+	/**
+	 * Patch the session's overrides (see {@link SessionOverrides}).
+	 *
+	 * Takes effect on the next inference each affected agent runs — running agents
+	 * are not rebuilt and a request already in flight completes on the model it
+	 * started with. Callers are expected to have validated the patch against the
+	 * preset; see `unknownOverrideTargets`.
+	 */
+	async setOverrides(patch: SessionOverridesPatch): Promise<Result<void, DomainError>> {
+		if (this.store.isClosed()) {
+			return Err(SessionErrors.closed(String(this.id)))
+		}
+
+		await this.store.emit(withSessionId(this.id, sessionEvents.create('session_overrides_set', patch)))
+
+		return Ok(undefined)
+	}
+
 	/**
 	 * Get an agent by ID.
 	 */

package/src/core/sessions/state.ts

@@ -6,6 +6,7 @@ import { agentEvents } from '~/core/agents/state.js'
 import { contextEvents } from '~/core/context/state.js'
 import { createEventsFactory } from '~/core/events/types'
 import type { DomainEvent } from '~/core/events/types.js'
+import { modelIdSchema } from '~/core/llm/schema.js'
 import { llmEvents } from '~/core/llm/state.js'
 import { SessionId, sessionIdSchema } from '~/core/sessions/schema.js'
 import type { PendingToolResult } from '~/core/tools/schema.js'
@@ -24,6 +25,65 @@ import { createTypedReducer } from './reducer.js'
  */
 export type SessionHandlerName = 'onSessionReady' | 'onSessionClose'
 
+// ============================================================================
+// Session overrides
+// ============================================================================
+
+/**
+ * Per-agent settings layered over the preset definition.
+ *
+ * Deliberately an object rather than a bare model id: the same layering is where
+ * `cacheTtl`, token caps or reasoning effort belong once they need to be
+ * session-scoped, and adding a field here stays backwards compatible.
+ */
+export const agentOverridesSchema = z4.object({
+	/** Replaces the model declared on the agent definition. */
+	model: modelIdSchema.optional(),
+})
+
+export type AgentOverrides = z4.infer<typeof agentOverridesSchema>
+
+/**
+ * A patch against {@link SessionOverrides}. An absent key is left alone, `null`
+ * clears it, and an object replaces that entry wholesale (it is not merged into
+ * the previous value — the entry *is* the override).
+ */
+export const sessionOverridesPatchSchema = z4.object({
+	defaults: agentOverridesSchema.nullable().optional(),
+	agents: z4.record(z4.string(), agentOverridesSchema.nullable()).optional(),
+})
+
+export type SessionOverridesPatch = z4.infer<typeof sessionOverridesPatchSchema>
+
+/**
+ * Session-scoped configuration layered over the preset, patchable at any time.
+ *
+ * Two levels because they answer different questions. `defaults` is "run this
+ * whole session on X"; `agents` is "…except this one". A preset that pins a
+ * cheap model to specific sub-agents (redo's `fastModel`) would have that intent
+ * flattened by `defaults` alone, so the per-definition level is what makes the
+ * override surgical.
+ */
+export interface SessionOverrides {
+	/** Applied to every agent that has no `agents` entry. */
+	defaults?: AgentOverrides
+	/** Keyed by definitionName, including ORCHESTRATOR_ROLE / COMMUNICATOR_ROLE. */
+	agents: Map<string, AgentOverrides>
+}
+
+/**
+ * Effective overrides for one agent definition: `agents` layered over `defaults`
+ * field by field, so `defaults: { model }` plus a per-agent entry that only sets
+ * some other field keeps the default model.
+ */
+export const resolveAgentOverrides = (
+	state: SessionState,
+	definitionName: string,
+): AgentOverrides => ({
+	...state.overrides.defaults,
+	...state.overrides.agents.get(definitionName),
+})
+
 export const sessionEvents = createEventsFactory({
 	events: {
 		session_created: z4.object({
@@ -44,6 +104,7 @@ export const sessionEvents = createEventsFactory({
 			key: z4.string(),
 			value: z4.unknown(),
 		}),
+		session_overrides_set: sessionOverridesPatchSchema,
 		session_handler_started: z4.object({
 			handlerName: z4.enum(['onSessionReady', 'onSessionClose']),
 			pluginName: z4.string(),
@@ -62,6 +123,7 @@ export type SessionClosedEvent = (typeof sessionEvents)['Events']['session_close
 export type SessionReopenedEvent = (typeof sessionEvents)['Events']['session_reopened']
 export type SessionRestartedEvent = (typeof sessionEvents)['Events']['session_restarted']
 export type SessionMetadataSetEvent = (typeof sessionEvents)['Events']['session_metadata_set']
+export type SessionOverridesSetEvent = (typeof sessionEvents)['Events']['session_overrides_set']
 export type SessionHandlerStartedEvent = (typeof sessionEvents)['Events']['session_handler_started']
 export type SessionHandlerCompletedEvent = (typeof sessionEvents)['Events']['session_handler_completed']
 
@@ -89,6 +151,8 @@ export interface SessionState {
 	workspaceDir?: string
 	/** Generic key-value metadata store (tool sets use their own keys) */
 	metadata: Map<string, unknown>
+	/** Session-scoped settings layered over the preset. See {@link SessionOverrides}. */
+	overrides: SessionOverrides
 	/** If this session was forked from another session */
 	forkedFrom?: { sessionId: SessionId; eventIndex: number }
 }
@@ -109,6 +173,7 @@ export const createSessionState = (
 	createdAt: timestamp,
 	agentCounters: new Map(),
 	metadata: new Map(),
+	overrides: { agents: new Map() },
 })
 
 // ============================================================================
@@ -429,6 +494,18 @@ export const coreReducer = createTypedReducer(
 				return { ...state, metadata: newMetadata }
 			}
 
+			case 'session_overrides_set': {
+				const agents = new Map(state.overrides.agents)
+				for (const [definitionName, override] of Object.entries(event.agents ?? {})) {
+					if (override === null) agents.delete(definitionName)
+					else agents.set(definitionName, override)
+				}
+				// undefined = untouched, null = cleared. `?? undefined` collapses the
+				// explicit null, which the state shape does not carry.
+				const defaults = event.defaults === undefined ? state.overrides.defaults : (event.defaults ?? undefined)
+				return { ...state, overrides: { defaults, agents } }
+			}
+
 			case 'agent_paused':
 				return updateAgent(state, event.agentId, (agent) => ({
 					...agent,

package/src/core/system.ts

@@ -10,6 +10,7 @@
 import type z4 from 'zod/v4'
 import type { Logger } from '~/lib/logger/logger.js'
 import type { Platform } from '~/platform/index.js'
+import type { ServicePidRegistry } from '~/plugins/services/pid-registry.js'
 import type { PortPool } from '~/plugins/services/port-pool.js'
 import type { PreprocessorRegistry } from '~/plugins/uploads/preprocessor.js'
 import type { EventStore } from './events/event-store.js'
@@ -120,6 +121,7 @@ export interface CreateSystemOptions<TPlugins extends readonly PluginDefinition<
 	preprocessorRegistry?: PreprocessorRegistry
 	llmLogger?: LLMLogger
 	portPool?: PortPool
+	pidRegistry?: ServicePidRegistry
 	/** Host-environment adapters (filesystem, process). */
 	platform: Platform
 }
@@ -145,6 +147,7 @@ export function createSystem<const TPlugins extends readonly PluginDefinition<st
 		preprocessorRegistry,
 		llmLogger,
 		portPool,
+		pidRegistry,
 		platform,
 	} = options
 
@@ -167,6 +170,7 @@ export function createSystem<const TPlugins extends readonly PluginDefinition<st
 		preprocessorRegistry,
 		llmLogger,
 		portPool,
+		pidRegistry,
 		platform,
 		systemPlugins: [...plugins],
 	})

package/src/index.ts

@@ -66,7 +66,14 @@ export { applyEvent } from '~/core/sessions/apply-event.js'
 export { selectPluginState } from '~/core/sessions/reducer.js'
 export { SessionId } from '~/core/sessions/schema.js'
 export type { SessionMetadata } from '~/core/sessions/schema.js'
-export { createSessionState, reconstructSessionState } from '~/core/sessions/state.js'
+export type { AgentOverrides, SessionOverrides, SessionOverridesPatch } from '~/core/sessions/state.js'
+export {
+	agentOverridesSchema,
+	createSessionState,
+	reconstructSessionState,
+	resolveAgentOverrides,
+	sessionOverridesPatchSchema,
+} from '~/core/sessions/state.js'
 export type { SessionState } from '~/core/sessions/state.js'
 export type { ToolCallId } from '~/core/tools/schema.js'
 export type { ToolStartedEvent } from '~/core/tools/state.js'