@pellux/goodvibes-sdk 0.30.3 → 0.33.1

package/dist/platform/control-plane/session-broker.js

@@ -1,10 +1,14 @@
-import { randomUUID } from 'node:crypto';
 import { logger } from '../utils/logger.js';
 import { sessionsActive } from '../runtime/metrics.js';
 import { PersistentStore } from '../state/persistent-store.js';
 import { RouteBindingManager } from '../channels/index.js';
-import { dedupeSessionSurfaceKinds, } from './session-broker-helpers.js';
-import { countPendingSessionInputs, createSessionBrokerSnapshot, loadSessionBrokerState, sortInputs, sortMessages, sortSessions, upsertSessionParticipant, } from './session-broker-state.js';
+import {} from './session-broker-helpers.js';
+import { createSessionBrokerSnapshot, loadSessionBrokerState, sortSessions, } from './session-broker-state.js';
+import { claimNextQueuedSessionInput, finalizeAgentSessionInputs, recordSharedSessionInput, refreshPendingInputCount, touchSharedSession, updateSharedSessionInput, } from './session-broker-inputs.js';
+import { appendSharedSessionMessage, buildSharedSessionContinuationTask, listSharedSessionMessages, } from './session-broker-messages.js';
+import { attachSharedSessionParticipantAndRoute, bindSharedSessionAgent, closeSharedSessionRecord, createSharedSessionRecord, reopenSharedSessionRecord, } from './session-broker-sessions.js';
+import { sweepSharedSessions } from './session-broker-gc.js';
+import { SharedSessionRuntimeBusBridge } from './session-broker-runtime-bus.js';
 const MAX_PERSISTED_MESSAGES = 2_000;
 const MAX_CONTINUATION_MESSAGES = 16;
 /** Max inputs retained per session bucket. */
@@ -23,12 +27,11 @@ export class SharedSessionBroker {
     sessions = new Map();
     messages = new Map();
     inputs = new Map();
+    runtimeBusBridge = new SharedSessionRuntimeBusBridge();
     eventPublisher = null;
     continuationRunner = null;
     loaded = false;
     _gcInterval = null;
-    _busUnsubs = [];
-    _busAttached = false;
     /** Default idle threshold for zero-message sessions (ms). */
     _idleEmptyMs;
     /** Default idle threshold for sessions with content (ms). */
@@ -66,26 +69,15 @@ export class SharedSessionBroker {
         return count;
     }
     /**
-     * M3: Gracefully stop the broker — clears GC interval, tears down bus subscriptions,
-     * and persists state. Call from DaemonServer.stop().
+     * Gracefully stop the broker by clearing the GC interval, tearing down bus
+     * subscriptions, and persisting state. Call from DaemonServer.stop().
      */
     async stop() {
         if (this._gcInterval) {
             clearInterval(this._gcInterval);
             this._gcInterval = null;
         }
-        for (const u of this._busUnsubs) {
-            try {
-                u();
-            }
-            catch (error) {
-                logger.warn('SharedSessionBroker bus unsubscribe failed', {
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            }
-        }
-        this._busUnsubs = [];
-        this._busAttached = false;
+        this.runtimeBusBridge.stopAll();
         await this.persist();
     }
     /**
@@ -100,58 +92,7 @@ export class SharedSessionBroker {
      *   Return `null` when the agent is not associated with a shared session.
      */
     attachRuntimeBus(bus, sessionResolver) {
-        // m3: idempotent — second call is a no-op with a warning
-        if (this._busAttached) {
-            // Emit via console.warn so call-sites that spy on console.warn can observe it.
-            console.warn('SharedSessionBroker.attachRuntimeBus: already attached, ignoring', { busAttached: true });
-            logger.warn('[SharedSessionBroker] attachRuntimeBus called more than once — ignoring duplicate call', {});
-            return () => { };
-        }
-        this._busAttached = true;
-        const onCompleted = bus.on('AGENT_COMPLETED', (envelope) => {
-            // m2: runtime type guard
-            if (typeof envelope.payload?.agentId !== 'string')
-                return;
-            const sessionId = sessionResolver(envelope.payload.agentId);
-            if (!sessionId)
-                return;
-            // m1: catch to prevent unhandled rejections
-            this.completeAgent(sessionId, envelope.payload.agentId, envelope.payload.output ?? '', { status: 'completed', durationMs: envelope.payload.durationMs }).catch((err) => {
-                logger.error('[SharedSessionBroker] completeAgent error on AGENT_COMPLETED', { error: String(err) });
-            });
-        });
-        const onFailed = bus.on('AGENT_FAILED', (envelope) => {
-            // m2: runtime type guard
-            if (typeof envelope.payload?.agentId !== 'string')
-                return;
-            const sessionId = sessionResolver(envelope.payload.agentId);
-            if (!sessionId)
-                return;
-            // m1: catch to prevent unhandled rejections
-            this.completeAgent(sessionId, envelope.payload.agentId, envelope.payload.error, { status: 'failed', durationMs: envelope.payload.durationMs }).catch((err) => {
-                logger.error('[SharedSessionBroker] completeAgent error on AGENT_FAILED', { error: String(err) });
-            });
-        });
-        const onCancelled = bus.on('AGENT_CANCELLED', (envelope) => {
-            // m2: runtime type guard
-            if (typeof envelope.payload?.agentId !== 'string')
-                return;
-            const sessionId = sessionResolver(envelope.payload.agentId);
-            if (!sessionId)
-                return;
-            // m1: catch to prevent unhandled rejections
-            this.completeAgent(sessionId, envelope.payload.agentId, envelope.payload.reason ?? 'cancelled', { status: 'cancelled' }).catch((err) => {
-                logger.error('[SharedSessionBroker] completeAgent error on AGENT_CANCELLED', { error: String(err) });
-            });
-        });
-        this._busUnsubs.push(onCompleted, onFailed, onCancelled);
-        return () => {
-            onCompleted();
-            onFailed();
-            onCancelled();
-            this._busAttached = false;
-            this._busUnsubs = this._busUnsubs.filter((fn) => fn !== onCompleted && fn !== onFailed && fn !== onCancelled);
-        };
+        return this.runtimeBusBridge.attach(bus, sessionResolver, (sessionId, agentId, body, metadata) => this.completeAgent(sessionId, agentId, body, metadata));
     }
     setContinuationRunner(runner) {
         this.continuationRunner = runner;
@@ -174,7 +115,7 @@ export class SharedSessionBroker {
             this.inputs.set(sessionId, bucket);
         }
         this.loaded = true;
-        // M2: startup reconciliation — cancel inputs stuck in spawned/delivered from a prior run
+        // Startup reconciliation cancels inputs stuck in spawned/delivered from a prior run.
         const restartReason = 'daemon restart — agent state unknown';
         for (const [sessionId, bucket] of this.inputs.entries()) {
             let changed = false;
@@ -195,8 +136,8 @@ export class SharedSessionBroker {
         }
         await this.persist();
         if (!this._gcInterval) {
-            // M3: .unref() so the GC interval does not keep the process alive past shutdown
-            const iv = setInterval(() => { this._gcSweep(); }, 60_000);
+            // .unref() so the GC interval does not keep the process alive past shutdown.
+            const iv = setInterval(() => { this.gcSweep(); }, 60_000);
             iv.unref?.();
             this._gcInterval = iv;
         }
@@ -240,57 +181,20 @@ export class SharedSessionBroker {
         });
     }
     getMessages(sessionId, limit = 100) {
-        const bucket = this.messages.get(sessionId) ?? [];
-        return bucket.slice(-Math.max(1, limit));
+        return listSharedSessionMessages(this.messageStore(), sessionId, limit);
     }
     getInputs(sessionId, limit = 100) {
         const bucket = this.inputs.get(sessionId) ?? [];
         return bucket.slice(-Math.max(1, limit));
     }
-    /**
-     * Reserved session IDs that must never be assigned to real sessions.
-     * Empty string is reserved to distinguish system-emitted events from user
-     * sessions. 'system' is reserved for runtime-authored records.
-     */
-    static RESERVED_SESSION_IDS = new Set(['', 'system']);
     async createSession(input = {}) {
-        if (input.id !== undefined && SharedSessionBroker.RESERVED_SESSION_IDS.has(input.id)) {
-            throw Object.assign(new Error(`INVALID_SESSION_ID: '${input.id}' is a reserved session ID and cannot be assigned to a real session.`), { code: 'INVALID_SESSION_ID' });
-        }
         await this.start();
-        const now = Date.now();
-        const sessionId = input.id ?? `sess-${randomUUID().slice(0, 8)}`;
-        const participant = input.participant;
-        const participants = participant ? [participant] : [];
-        const routeIds = input.routeBinding?.id ? [input.routeBinding.id] : [];
-        const session = {
-            id: sessionId,
-            kind: input.kind ?? 'tui',
-            title: input.title?.trim() || input.routeBinding?.title || `Session ${sessionId}`,
-            status: 'active',
-            createdAt: now,
-            updatedAt: now,
-            lastMessageAt: undefined,
-            closedAt: undefined,
-            lastActivityAt: now,
-            messageCount: 0,
-            pendingInputCount: 0,
-            routeIds,
-            surfaceKinds: participant ? [participant.surfaceKind] : input.routeBinding ? [input.routeBinding.surfaceKind] : [],
-            participants,
-            activeAgentId: undefined,
-            lastAgentId: undefined,
-            lastError: undefined,
-            metadata: {
-                ...(input.metadata ?? {}),
-            },
-        };
+        const session = createSharedSessionRecord(input);
         this.sessions.set(session.id, session);
         if (input.routeBinding?.id) {
             await this.routeBindings.patchBinding(input.routeBinding.id, { sessionId: session.id });
         }
         await this.persist();
-        // C-1: update active session gauge
         sessionsActive.set(this.sessions.size);
         this.publishUpdate('session-created', session);
         return session;
@@ -300,19 +204,11 @@ export class SharedSessionBroker {
         const session = this.sessions.get(sessionId);
         if (!session)
             return null;
-        this._touch(sessionId); // M4: uniform touch before mutation
+        this.touch(sessionId);
         const touched = this.sessions.get(sessionId); // re-fetch after touch
-        const now = Date.now();
-        const updated = {
-            ...touched,
-            status: 'closed',
-            activeAgentId: undefined,
-            updatedAt: now,
-            closedAt: now,
-        };
+        const updated = closeSharedSessionRecord(touched);
         this.sessions.set(sessionId, updated);
         await this.persist();
-        // C-1: update active session gauge
         sessionsActive.set(this.sessions.size);
         this.publishUpdate('session-closed', updated);
         return updated;
@@ -322,12 +218,7 @@ export class SharedSessionBroker {
         const session = this.sessions.get(sessionId);
         if (!session)
             return null;
-        const updated = {
-            ...session,
-            status: 'active',
-            updatedAt: Date.now(),
-            closedAt: undefined,
-        };
+        const updated = reopenSharedSessionRecord(session);
         this.sessions.set(sessionId, updated);
         await this.persist();
         this.publishUpdate('session-reopened', updated);
@@ -338,13 +229,7 @@ export class SharedSessionBroker {
         const session = this.sessions.get(sessionId);
         if (!session)
             return null;
-        const updated = {
-            ...session,
-            activeAgentId: agentId,
-            lastAgentId: agentId,
-            updatedAt: Date.now(),
-            lastActivityAt: Date.now(),
-        };
+        const updated = bindSharedSessionAgent(session, agentId);
         this.sessions.set(sessionId, updated);
         const claimed = this.claimNextQueuedInput(sessionId, agentId);
         await this.persist();
@@ -410,10 +295,9 @@ export class SharedSessionBroker {
             activeAgentId: (this.sessions.get(sessionId)?.activeAgentId === agentId) ? undefined : this.sessions.get(sessionId)?.activeAgentId,
             lastAgentId: agentId,
             updatedAt: now,
-            lastActivityAt: now, // M4: completeAgent explicitly updates lastActivityAt
+            lastActivityAt: now,
             ...(metadata.status === 'failed' ? { lastError: body } : {}),
         };
-        this._touch(sessionId); // M4: touch after mutation
         this.sessions.set(sessionId, updated);
         const finalizedInputs = this.finalizeAgentInputs(sessionId, agentId, metadata.status === 'failed' ? 'failed' : metadata.status === 'cancelled' ? 'cancelled' : 'completed', metadata.status === 'failed' ? body : undefined);
         await this.persist();
@@ -470,37 +354,10 @@ export class SharedSessionBroker {
     }
     async appendMessage(sessionId, input) {
         await this.start();
-        const message = {
-            id: `smsg-${randomUUID().slice(0, 8)}`,
+        const message = appendSharedSessionMessage(this.messageStore(), {
             sessionId,
-            role: input.role,
-            body: input.body,
-            createdAt: Date.now(),
-            surfaceKind: input.surfaceKind,
-            surfaceId: input.surfaceId,
-            routeId: input.routeId,
-            agentId: input.agentId,
-            userId: input.userId,
-            displayName: input.displayName,
-            metadata: input.metadata ?? {},
-        };
-        const bucket = this.messages.get(sessionId) ?? [];
-        bucket.push(message);
-        while (bucket.length > MAX_PERSISTED_MESSAGES) {
-            bucket.shift();
-        }
-        this.messages.set(sessionId, bucket);
-        const session = this.sessions.get(sessionId);
-        if (session) {
-            const updated = {
-                ...session,
-                messageCount: bucket.length,
-                lastMessageAt: message.createdAt,
-                updatedAt: message.createdAt,
-                lastActivityAt: message.createdAt,
-            };
-            this.sessions.set(sessionId, updated);
-        }
+            ...input,
+        }, MAX_PERSISTED_MESSAGES);
         await this.persist();
         this.publishUpdate('session-message-appended', {
             sessionId,
@@ -509,33 +366,9 @@ export class SharedSessionBroker {
         return message;
     }
     async attachParticipantAndRoute(session, input, binding) {
-        this._touch(session.id); // M4
+        this.touch(session.id);
         const existing = this.sessions.get(session.id) ?? session;
-        const nextRouteIds = binding?.id
-            ? [...new Set([...existing.routeIds, binding.id])]
-            : [...existing.routeIds];
-        const participants = upsertSessionParticipant(existing.participants, {
-            surfaceKind: input.surfaceKind,
-            surfaceId: input.surfaceId,
-            externalId: input.externalId,
-            userId: input.userId,
-            displayName: input.displayName,
-            routeId: binding?.id,
-            lastSeenAt: Date.now(),
-        });
-        const updated = {
-            ...existing,
-            title: input.title?.trim() || existing.title,
-            status: existing.status === 'closed' ? 'active' : existing.status,
-            updatedAt: Date.now(),
-            closedAt: existing.status === 'closed' ? undefined : existing.closedAt,
-            routeIds: nextRouteIds,
-            participants,
-            surfaceKinds: dedupeSessionSurfaceKinds(participants),
-            metadata: {
-                ...existing.metadata,
-            },
-        };
+        const updated = attachSharedSessionParticipantAndRoute({ session: existing, message: input, binding });
         this.sessions.set(updated.id, updated);
         if (binding?.id) {
             await this.routeBindings.patchBinding(binding.id, { sessionId: updated.id });
@@ -564,23 +397,11 @@ export class SharedSessionBroker {
         return this.routeBindings.resolve(input.surfaceKind, input.externalId, input.threadId) ?? null;
     }
     buildContinuationTask(sessionId) {
-        const session = this.sessions.get(sessionId);
-        const history = this.getMessages(sessionId, MAX_CONTINUATION_MESSAGES);
-        const transcript = history
-            .map((message) => {
-            const speaker = message.role === 'assistant'
-                ? 'Assistant'
-                : message.role === 'system'
-                    ? 'System'
-                    : `${message.displayName ?? message.userId ?? 'User'}`;
-            return `${speaker}: ${message.body}`;
-        })
-            .join('\n\n');
-        return [
-            `Continue the shared control-plane session "${session?.title ?? sessionId}".`,
-            'Preserve continuity with the recent transcript and answer the newest user message directly.',
-            transcript ? `Recent transcript:\n${transcript}` : '',
-        ].filter(Boolean).join('\n\n');
+        return buildSharedSessionContinuationTask({
+            session: this.sessions.get(sessionId) ?? null,
+            messages: this.getMessages(sessionId, MAX_CONTINUATION_MESSAGES),
+            fallbackSessionId: sessionId,
+        });
     }
     async persist() {
         await this.store.persist(createSessionBrokerSnapshot({
@@ -741,94 +562,23 @@ export class SharedSessionBroker {
         };
     }
     recordInput(sessionId, intent, input, routeId, causationId) {
-        this._touch(sessionId); // M4
-        const id = `sin-${randomUUID().slice(0, 8)}`;
-        const entry = {
-            id,
+        return recordSharedSessionInput(this.sessionInputStore(), {
             sessionId,
             intent,
-            state: 'queued',
-            correlationId: typeof input.metadata?.correlationId === 'string' ? input.metadata.correlationId : `session-input:${id}`,
-            ...(causationId ? { causationId } : {}),
-            body: input.body,
-            createdAt: Date.now(),
-            updatedAt: Date.now(),
+            message: input,
             routeId,
-            surfaceKind: input.surfaceKind,
-            surfaceId: input.surfaceId,
-            externalId: input.externalId,
-            threadId: input.threadId,
-            userId: input.userId,
-            displayName: input.displayName,
-            metadata: input.metadata ?? {},
-            routing: input.routing,
-        };
-        const bucket = this.inputs.get(sessionId) ?? [];
-        bucket.push(entry);
-        // Cap input bucket to prevent unbounded growth (PERF-01 / MAX_PERSISTED_INPUTS).
-        const sorted = sortInputs(bucket);
-        if (sorted.length > MAX_PERSISTED_INPUTS) {
-            sorted.splice(0, sorted.length - MAX_PERSISTED_INPUTS);
-        }
-        this.inputs.set(sessionId, sorted);
-        this.refreshPendingInputCount(sessionId);
-        return entry;
+            causationId,
+            maxPersistedInputs: MAX_PERSISTED_INPUTS,
+        });
     }
     updateInput(sessionId, inputId, transform) {
-        const bucket = this.inputs.get(sessionId);
-        if (!bucket)
-            return null;
-        const index = bucket.findIndex((entry) => entry.id === inputId);
-        if (index < 0)
-            return null;
-        const updated = transform(bucket[index]);
-        bucket[index] = updated;
-        this.inputs.set(sessionId, bucket);
-        this.refreshPendingInputCount(sessionId);
-        this._touch(sessionId); // M4
-        return updated;
+        return updateSharedSessionInput(this.sessionInputStore(), sessionId, inputId, transform);
     }
     claimNextQueuedInput(sessionId, agentId) {
-        const bucket = this.inputs.get(sessionId) ?? [];
-        const next = bucket.find((entry) => entry.state === 'queued');
-        if (!next)
-            return null;
-        const result = this.updateInput(sessionId, next.id, (entry) => ({
-            ...entry,
-            state: 'spawned',
-            activeAgentId: agentId,
-            updatedAt: Date.now(),
-        }));
-        this._touch(sessionId); // M4
-        return result;
+        return claimNextQueuedSessionInput(this.sessionInputStore(), sessionId, agentId);
     }
     finalizeAgentInputs(sessionId, agentId, nextState, error) {
-        const bucket = this.inputs.get(sessionId);
-        if (!bucket)
-            return [];
-        this._touch(sessionId); // M4: ensure direct callers also bump session timestamps
-        let changed = false;
-        const updatedInputs = [];
-        for (let index = 0; index < bucket.length; index += 1) {
-            const entry = bucket[index];
-            if (entry.activeAgentId !== agentId)
-                continue;
-            if (entry.state !== 'delivered' && entry.state !== 'spawned')
-                continue;
-            bucket[index] = {
-                ...entry,
-                state: nextState,
-                updatedAt: Date.now(),
-                ...(error ? { error } : {}),
-            };
-            updatedInputs.push(bucket[index]);
-            changed = true;
-        }
-        if (changed) {
-            this.inputs.set(sessionId, bucket);
-            this.refreshPendingInputCount(sessionId);
-        }
-        return updatedInputs;
+        return finalizeAgentSessionInputs(this.sessionInputStore(), sessionId, agentId, nextState, error);
     }
     async runQueuedFollowUp(sessionId) {
         if (!this.continuationRunner)
@@ -857,24 +607,17 @@ export class SharedSessionBroker {
         await this.persist();
         return claimed ? { input: claimed, agentId: spawned.agentId } : null;
     }
-    // M4: touch helper — bumps lastActivityAt + updatedAt on a session
-    _touch(sessionId) {
-        const s = this.sessions.get(sessionId);
-        if (!s)
-            return;
-        const now = Date.now();
-        this.sessions.set(sessionId, { ...s, lastActivityAt: now, updatedAt: now });
+    sessionInputStore() {
+        return { sessions: this.sessions, inputs: this.inputs };
+    }
+    messageStore() {
+        return { sessions: this.sessions, messages: this.messages };
+    }
+    touch(sessionId) {
+        touchSharedSession(this.sessionInputStore(), sessionId);
     }
     refreshPendingInputCount(sessionId) {
-        const session = this.sessions.get(sessionId);
-        if (!session)
-            return;
-        const pendingInputCount = countPendingSessionInputs(this.inputs.get(sessionId) ?? []);
-        this.sessions.set(sessionId, {
-            ...session,
-            pendingInputCount,
-            updatedAt: Date.now(),
-        });
+        refreshPendingInputCount(this.sessionInputStore(), sessionId);
     }
     /**
      * Periodic idle-session GC sweep.
@@ -888,49 +631,13 @@ export class SharedSessionBroker {
      * "Idle" is measured from `lastActivityAt` (updated on createInput/bindAgent/
      * appendMessage). Sessions with an active agent are never GC'd.
      */
-    _gcSweep() {
-        const now = Date.now();
-        let anyChanged = false; // m4: track changed inline, not a second O(n) scan
-        for (const [sessionId, session] of this.sessions.entries()) {
-            // Hard-delete sessions that have been closed past the retention window.
-            // This prevents unbounded growth of sessions/messages/inputs Maps (PERF-01).
-            if (session.status === 'closed') {
-                const closedAt = session.closedAt ?? session.updatedAt;
-                if (now - closedAt >= SESSION_DELETION_RETENTION_MS) {
-                    this.sessions.delete(sessionId);
-                    this.messages.delete(sessionId);
-                    this.inputs.delete(sessionId);
-                    anyChanged = true;
-                }
-                continue;
-            }
-            if (session.status !== 'active')
-                continue;
-            if (session.activeAgentId)
-                continue; // live agent — leave it
-            if (session.pendingInputCount > 0)
-                continue; // M4: never close sessions with pending inputs
-            const idle = now - session.lastActivityAt;
-            let reason = null;
-            if (session.messageCount === 0 && idle >= this._idleEmptyMs) {
-                reason = 'idle-empty';
-            }
-            else if (session.messageCount > 0 && idle >= this._idleLongMs) {
-                reason = 'idle-long';
-            }
-            if (!reason)
-                continue;
-            const closed = {
-                ...session,
-                status: 'closed',
-                activeAgentId: undefined,
-                updatedAt: now,
-                closedAt: now,
-            };
-            this.sessions.set(sessionId, closed);
-            this.publishUpdate('session-closed', { ...closed, reason });
-            anyChanged = true; // m4: set during loop, not a second scan
-        }
+    gcSweep() {
+        const anyChanged = sweepSharedSessions({ sessions: this.sessions, messages: this.messages, inputs: this.inputs }, {
+            idleEmptyMs: this._idleEmptyMs,
+            idleLongMs: this._idleLongMs,
+            deletionRetentionMs: SESSION_DELETION_RETENTION_MS,
+            publishUpdate: (event, payload) => this.publishUpdate(event, payload),
+        });
         if (anyChanged) {
             void this.persist().catch((error) => {
                 logger.warn('[session-broker] GC persistence failed', {

package/dist/platform/control-plane/session-intents.d.ts

@@ -1,6 +1,6 @@
 import type { AutomationRouteBinding } from '../automation/routes.js';
 import type { AutomationSurfaceKind } from '../automation/types.js';
-import type { ProviderFailurePolicy, ProviderRoutingSelection, UnresolvedModelPolicy } from '../automation/types.js';
+import type { ProviderFailurePolicy, ProviderRoutingSelection } from '../automation/types.js';
 import type { ExecutionIntent } from '../runtime/execution-intents.js';
 export declare const SHARED_SESSION_INPUT_INTENTS: readonly ["submit", "steer", "follow-up"];
 export declare const SHARED_SESSION_INPUT_STATES: readonly ["queued", "delivered", "spawned", "completed", "cancelled", "failed", "rejected"];
@@ -11,16 +11,15 @@ export interface SharedSessionHelperModelOverride {
     readonly modelId: string;
 }
 export interface SharedSessionRoutingIntent {
-    readonly providerId?: string;
-    readonly modelId?: string;
-    readonly providerSelection?: ProviderRoutingSelection;
-    readonly unresolvedModelPolicy?: UnresolvedModelPolicy;
-    readonly providerFailurePolicy?: ProviderFailurePolicy;
-    readonly fallbackModels?: readonly string[];
-    readonly helperModel?: SharedSessionHelperModelOverride;
-    readonly executionIntent?: ExecutionIntent;
-    readonly tools?: readonly string[];
-    readonly reasoningEffort?: 'instant' | 'low' | 'medium' | 'high';
+    readonly providerId?: string | undefined;
+    readonly modelId?: string | undefined;
+    readonly providerSelection?: ProviderRoutingSelection | undefined;
+    readonly providerFailurePolicy?: ProviderFailurePolicy | undefined;
+    readonly fallbackModels?: readonly string[] | undefined;
+    readonly helperModel?: SharedSessionHelperModelOverride | undefined;
+    readonly executionIntent?: ExecutionIntent | undefined;
+    readonly tools?: readonly string[] | undefined;
+    readonly reasoningEffort?: 'instant' | 'low' | 'medium' | 'high' | undefined;
 }
 export interface SharedSessionInputRecord {
     readonly id: string;
@@ -28,38 +27,54 @@ export interface SharedSessionInputRecord {
     readonly intent: SharedSessionInputIntent;
     readonly state: SharedSessionInputState;
     readonly correlationId: string;
-    readonly causationId?: string;
+    readonly causationId?: string | undefined;
     readonly body: string;
     readonly createdAt: number;
     readonly updatedAt: number;
-    readonly routeId?: string;
-    readonly surfaceKind?: AutomationSurfaceKind;
-    readonly surfaceId?: string;
-    readonly externalId?: string;
-    readonly threadId?: string;
-    readonly userId?: string;
-    readonly displayName?: string;
-    readonly activeAgentId?: string;
+    readonly routeId?: string | undefined;
+    readonly surfaceKind?: AutomationSurfaceKind | undefined;
+    readonly surfaceId?: string | undefined;
+    readonly externalId?: string | undefined;
+    readonly threadId?: string | undefined;
+    readonly userId?: string | undefined;
+    readonly displayName?: string | undefined;
+    readonly activeAgentId?: string | undefined;
     readonly metadata: Record<string, unknown>;
-    readonly routing?: SharedSessionRoutingIntent;
-    readonly error?: string;
+    readonly routing?: SharedSessionRoutingIntent | undefined;
+    readonly error?: string | undefined;
 }
 export interface SharedSessionContinuationRequest {
     readonly sessionId: string;
     readonly input: SharedSessionInputRecord;
     readonly task: string;
-    readonly routeBinding?: AutomationRouteBinding;
+    readonly routeBinding?: AutomationRouteBinding | undefined;
 }
 export interface SharedSessionContinuationResult {
     readonly agentId: string;
 }
 export type SharedSessionContinuationRunner = (input: SharedSessionContinuationRequest) => SharedSessionContinuationResult | Promise<SharedSessionContinuationResult | null> | null;
+export interface SharedSessionAgentSpawnRoutingInput {
+    readonly model?: string | undefined;
+    readonly provider?: string | undefined;
+    readonly tools?: string[] | undefined;
+    readonly restrictTools?: boolean | undefined;
+    readonly routing?: {
+        readonly providerSelection?: ProviderRoutingSelection | undefined;
+        readonly providerFailurePolicy?: ProviderFailurePolicy | undefined;
+        readonly fallbackModels?: string[] | undefined;
+    } | undefined;
+    readonly executionIntent?: ExecutionIntent | undefined;
+    readonly reasoningEffort?: 'instant' | 'low' | 'medium' | 'high' | undefined;
+}
+export declare function buildSharedSessionAgentSpawnRoutingInput(routing: SharedSessionRoutingIntent | undefined, options?: {
+    readonly restrictTools?: boolean | undefined;
+}): SharedSessionAgentSpawnRoutingInput;
 export interface SharedSessionCompletion {
     readonly session: {
         readonly id: string;
-        readonly activeAgentId?: string;
+        readonly activeAgentId?: string | undefined;
     };
-    readonly continuedInput?: SharedSessionInputRecord;
-    readonly continuedAgentId?: string;
+    readonly continuedInput?: SharedSessionInputRecord | undefined;
+    readonly continuedAgentId?: string | undefined;
 }
 //# sourceMappingURL=session-intents.d.ts.map