gestalt-mobile 0.35.4 → 0.36.0

package/dist/server/server/platform/kimi/kimi-session-runtime.js

@@ -0,0 +1,653 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { createHash, randomUUID } from 'node:crypto';
+import { RelaySession, } from '../../features/sessions/model/relay-session.js';
+import { normalizeSkillProfileName, } from '../../features/skills/model/skill-profile.js';
+import { WriterAcquisitionError, } from '../../features/sessions/application/writer-acquisition.js';
+import { isKimiWebError } from './kimi-errors.js';
+import { KimiWsClient } from './kimi-ws-client.js';
+import { approvalToServerRequest, decodeApprovalItems, decodeQuestionItems, kimiApprovalDecision, kimiQuestionAnswers, questionToServerRequest, } from './kimi-server-request.js';
+const KIMI_SESSION_NOT_RUNNING = 'KIMI_SESSION_NOT_RUNNING';
+const KIMI_UNSUPPORTED = 'KIMI_UNSUPPORTED';
+/**
+ * Drives relay sessions through a gestalt-owned `kimi web` server. Implements
+ * the same runtime surface the composition consumes from CodexSessionRuntime
+ * for the core chat path (start/restore/turns/steering/interrupt/history/
+ * approvals/questions/release). Codex-only surfaces — autopilot executors,
+ * supervised-plan measurement, child-process reconciliation — throw
+ * `KIMI_UNSUPPORTED` and are never offered for kimi sessions upstream.
+ */
+export class KimiSessionRuntime {
+    input;
+    sessions = new Map();
+    connections = new Map();
+    writerAcquisitions = new Map();
+    historyReads = new Map();
+    constructor(input) {
+        this.input = input;
+    }
+    /**
+     * Per-session translation context for the event normalizer and activity
+     * facts decoder: kimi per-agent turn numbers resolve to prompt turn ids,
+     * and spawned subagent ids are tracked as child agents.
+     */
+    eventContext(sessionId) {
+        const resource = this.sessions.get(sessionId);
+        if (!resource)
+            return { resolveTurnId: () => null, isChildAgent: () => false };
+        return {
+            resolveTurnId: (agentId, turnNumber) => resource.agentTurns.get(`${agentId}:${turnNumber}`) ?? null,
+            isChildAgent: (agentId) => resource.childAgents.has(agentId),
+        };
+    }
+    async start(session, now) {
+        const handle = await this.ensureServer(session);
+        const created = (await handle.client.post('/api/v1/sessions', {
+            metadata: { cwd: session.workspacePath },
+        }));
+        if (!created.id || typeof created.id !== 'string')
+            throw new Error('KIMI_SESSION_CREATE_FAILED');
+        await this.applyProfile(handle, created.id, session);
+        await this.attachResource(session, created.id, handle);
+        return RelaySession.rehydrate(session).bindThread(created.id, now).snapshot;
+    }
+    stop(sessionId) {
+        const resource = this.sessions.get(sessionId);
+        if (!resource)
+            return;
+        resource.explicitShutdown = true;
+        this.detach(sessionId);
+    }
+    async release(sessionId) {
+        const resource = this.sessions.get(sessionId);
+        if (resource)
+            resource.explicitShutdown = true;
+        await this.detach(sessionId);
+    }
+    async recycle(session, now) {
+        this.stop(session.id);
+        return this.restore(session, now);
+    }
+    stopAll() {
+        for (const resource of this.sessions.values())
+            resource.explicitShutdown = true;
+        for (const sessionId of [...this.sessions.keys()])
+            this.detach(sessionId);
+    }
+    ownsWriter(sessionId) {
+        return this.sessions.get(sessionId)?.active === true;
+    }
+    async ensureWriter(session, now) {
+        if (this.ownsWriter(session.id))
+            return { session, replacementCreated: false };
+        const inflight = this.writerAcquisitions.get(session.id);
+        if (inflight)
+            return inflight;
+        const acquisition = this.acquireWriter(session, now);
+        this.writerAcquisitions.set(session.id, acquisition);
+        try {
+            return await acquisition;
+        }
+        finally {
+            if (this.writerAcquisitions.get(session.id) === acquisition)
+                this.writerAcquisitions.delete(session.id);
+        }
+    }
+    async startTurn(session, text, clientUserMessageId, now) {
+        const resource = this.requireResource(session);
+        const promptId = clientUserMessageId ?? randomUUID();
+        await this.submitPrompt(resource, promptId, text, session.model);
+        return RelaySession.rehydrate(session).startTurn(promptId, now).snapshot;
+    }
+    /** kimi queues prompts server-side while a turn runs; submitPrompt steers
+     * the queued prompt into the active turn, which is the steering equivalent. */
+    async queueTurnInput(session, _turnId, text, clientUserMessageId) {
+        const resource = this.requireResource(session);
+        await this.submitPrompt(resource, clientUserMessageId ?? randomUUID(), text, session.model);
+    }
+    async interruptTurn(session, turnId) {
+        const resource = this.requireResource(session);
+        const handle = this.input.servers.get(resource.profileKey);
+        if (!handle)
+            throw new Error(KIMI_SESSION_NOT_RUNNING);
+        await handle.client.post(`/api/v1/sessions/${resource.threadId}/prompts/${turnId}:abort`);
+    }
+    async readHistory(session) {
+        if (!session.threadId)
+            throw new Error('KIMI_THREAD_ID_MISSING');
+        const owned = this.sessions.get(session.id);
+        if (owned)
+            return this.readHistoryFrom(owned);
+        const existing = this.historyReads.get(session.id);
+        if (existing)
+            return existing;
+        const read = this.readDetachedHistory(session);
+        this.historyReads.set(session.id, read);
+        try {
+            return await read;
+        }
+        finally {
+            if (this.historyReads.get(session.id) === read)
+                this.historyReads.delete(session.id);
+        }
+    }
+    async resolveServerRequest(sessionId, requestId, result) {
+        const resource = this.sessions.get(sessionId);
+        const pending = resource?.pendingInteractions.get(requestId);
+        if (!resource || !pending || pending.settling)
+            return false;
+        pending.settling = true;
+        try {
+            await this.resolveInteraction(resource, pending, result);
+            resource.pendingInteractions.delete(requestId);
+            return true;
+        }
+        catch {
+            pending.settling = false;
+            return false;
+        }
+    }
+    rejectServerRequest(sessionId, requestId) {
+        const resource = this.sessions.get(sessionId);
+        const pending = resource?.pendingInteractions.get(requestId);
+        if (!resource || !pending || pending.settling)
+            return false;
+        pending.settling = true;
+        void this.resolveInteraction(resource, pending, 'cancel').then(() => resource.pendingInteractions.delete(requestId), () => {
+            pending.settling = false;
+        });
+        return true;
+    }
+    abandonServerRequest(sessionId, requestId) {
+        return this.sessions.get(sessionId)?.pendingInteractions.delete(requestId) === true;
+    }
+    attentionWriterState(sessionId, requestId) {
+        const resource = this.sessions.get(sessionId);
+        if (!resource || !resource.active)
+            return 'unavailable';
+        const pending = resource.pendingInteractions.get(requestId);
+        return pending && !pending.settling ? 'available' : 'cleared';
+    }
+    async restore(session, now) {
+        return (await this.restoreWithOutcome(session, now)).session;
+    }
+    async restoreWithOutcome(session, now) {
+        try {
+            const restored = await this.attachExisting(session);
+            return { session: restored, historyUnavailable: false, replacementCreated: false };
+        }
+        catch (error) {
+            if (!isKimiSessionMissing(error))
+                throw error;
+            // The kimi session disappeared server-side (pruned or share-dir loss):
+            // bind a replacement thread, mirroring the codex missing-rollout policy.
+            const replacement = await this.start(session, now);
+            return { session: replacement, historyUnavailable: true, replacementCreated: true };
+        }
+    }
+    // --- Codex-only surfaces: kimi sessions never reach these upstream. ---
+    async startExecutorTurn() {
+        throw new Error(KIMI_UNSUPPORTED);
+    }
+    async interruptExecutor() {
+        throw new Error(KIMI_UNSUPPORTED);
+    }
+    async listDirectChildren() {
+        return [];
+    }
+    async inspectChildProcesses() {
+        return [];
+    }
+    consumeChildProcessResult() {
+        throw new Error(KIMI_UNSUPPORTED);
+    }
+    async terminateChildProcess() {
+        throw new Error(KIMI_UNSUPPORTED);
+    }
+    async readPlanMeasurement() {
+        throw new Error(KIMI_UNSUPPORTED);
+    }
+    authorizePlanMeasurement() {
+        return false;
+    }
+    async syncThreadPlanName() { }
+    async watchPlanStatus() { }
+    // --- internals ---
+    async acquireWriter(session, now) {
+        try {
+            const restored = await this.restoreWithOutcome(session, now);
+            return { session: restored.session, replacementCreated: restored.replacementCreated };
+        }
+        catch (error) {
+            throw classifyWriterAcquisitionFailure(error);
+        }
+    }
+    /**
+     * Servers are keyed by the canonical skill selection: sessions sharing one
+     * effective selection share one kimi web process. The empty (native)
+     * selection uses the stable `default` key; anything else uses a short hash
+     * of its path-sorted entries (hex fits the skill-profile name pattern).
+     */
+    profileKey(session) {
+        const effective = session.effectiveSkillSelection;
+        const selection = effective?.skills ?? [];
+        if (effective?.selectedProfileName)
+            return normalizeSkillProfileName(effective.selectedProfileName);
+        if (!selection.length)
+            return 'default';
+        const canonical = JSON.stringify([...selection].sort((a, b) => a.path.localeCompare(b.path)));
+        return `sel-${createHash('sha256').update(canonical).digest('hex').slice(0, 12)}`;
+    }
+    async ensureServer(session) {
+        // A recent thread imported from a running Kimi server carries that server's
+        // profile key in `profile`, but no reconstructable effective skill selection.
+        // Reuse its exact owner; never collapse it onto the default server or restart
+        // it with an empty selection.
+        if (!session.effectiveSkillSelection) {
+            const existing = this.input.servers.get(normalizeSkillProfileName(session.profile));
+            if (existing)
+                return existing;
+            throw new Error(KIMI_SESSION_NOT_RUNNING);
+        }
+        const skills = await this.input.skillsFor(session);
+        return this.input.servers.ensure(this.profileKey(session), skills ?? session.effectiveSkillSelection?.skills ?? []);
+    }
+    async applyProfile(handle, threadId, session) {
+        await handle.client.post(`/api/v1/sessions/${threadId}/profile`, {
+            agent_config: {
+                ...(session.model ? { model: session.model } : {}),
+                permission_mode: kimiPermissionMode(session),
+            },
+        });
+    }
+    async attachResource(session, threadId, handle) {
+        await this.detach(session.id);
+        const resource = {
+            sessionId: session.id,
+            profileKey: handle.profileKey,
+            threadId,
+            active: true,
+            explicitShutdown: false,
+            cursor: 0,
+            pendingPrompts: [],
+            agentTurns: new Map(),
+            activePromptId: null,
+            childAgents: new Set(),
+            mainAgentId: null,
+            pendingInteractions: new Map(),
+            interactionSequence: 0,
+            pollInFlight: null,
+        };
+        this.sessions.set(session.id, resource);
+        await this.subscribe(resource, handle);
+        return resource;
+    }
+    /** Attaches to the durable kimi session recorded on the relay snapshot. */
+    async attachExisting(session) {
+        if (!session.threadId)
+            throw new Error('KIMI_THREAD_ID_MISSING');
+        const handle = await this.ensureServer(session);
+        await handle.client.get(`/api/v1/sessions/${session.threadId}`);
+        await this.applyProfile(handle, session.threadId, session);
+        await this.attachResource(session, session.threadId, handle);
+        return session;
+    }
+    async subscribe(resource, handle) {
+        const connection = await this.ensureConnection(handle);
+        connection.sessions.add(resource.sessionId);
+        await connection.client.subscribe([resource.threadId], {
+            [resource.threadId]: { seq: resource.cursor },
+        });
+    }
+    async ensureConnection(handle) {
+        const existing = this.connections.get(handle.profileKey);
+        if (existing)
+            return existing;
+        const client = this.input.wsClientFor?.(handle) ?? new KimiWsClient(handle.baseUrl, handle.token);
+        const connection = {
+            client,
+            sessions: new Set(),
+            eventUnsub: client.onEvent((event) => this.dispatchEvent(handle.profileKey, event)),
+            closeUnsub: client.onClose(() => this.handleConnectionClose(handle.profileKey)),
+        };
+        this.connections.set(handle.profileKey, connection);
+        try {
+            await client.connect();
+        }
+        catch (error) {
+            connection.eventUnsub();
+            connection.closeUnsub();
+            this.connections.delete(handle.profileKey);
+            throw error;
+        }
+        return connection;
+    }
+    handleConnectionClose(profileKey) {
+        const connection = this.connections.get(profileKey);
+        if (!connection)
+            return;
+        this.connections.delete(profileKey);
+        for (const sessionId of connection.sessions) {
+            const resource = this.sessions.get(sessionId);
+            if (resource)
+                resource.active = false;
+        }
+        for (const sessionId of connection.sessions)
+            this.input.onExit?.(sessionId);
+    }
+    dispatchEvent(profileKey, event) {
+        const sessionId = this.relaySessionId(profileKey, event.session_id);
+        const resource = sessionId ? this.sessions.get(sessionId) : undefined;
+        if (!sessionId || !resource)
+            return;
+        if (typeof event.seq === 'number' && event.seq > resource.cursor)
+            resource.cursor = event.seq;
+        this.consumeProtocolEvent(resource, event);
+        const origin = this.originFor(resource, event);
+        this.input.onNotification(sessionId, event, origin);
+    }
+    /** Maps a kimi session id back to the owning relay session on this connection. */
+    relaySessionId(profileKey, threadId) {
+        if (!threadId)
+            return null;
+        for (const resource of this.sessions.values()) {
+            if (resource.profileKey === profileKey && resource.threadId === threadId)
+                return resource.sessionId;
+        }
+        return null;
+    }
+    originFor(resource, event) {
+        const agentId = agentIdOf(event.payload);
+        if (agentId && resource.childAgents.has(agentId)) {
+            const turnNumber = turnNumberOf(event.payload);
+            return {
+                kind: 'child',
+                ...(agentId && turnNumber !== null ? { physicalTurnId: `${agentId}:${turnNumber}` } : {}),
+            };
+        }
+        return { kind: 'root' };
+    }
+    /** Consumes protocol facts the runtime itself owns (turn/prompt bindings, interactions). */
+    consumeProtocolEvent(resource, event) {
+        const payload = record(event.payload);
+        if (!payload)
+            return;
+        switch (payload.type) {
+            case 'turn.started': {
+                const agentId = typeof payload.agentId === 'string' ? payload.agentId : null;
+                const turnNumber = safeTurnNumber(payload.turnId);
+                if (!agentId || turnNumber === null)
+                    break;
+                if (resource.mainAgentId === null && resource.pendingPrompts.length) {
+                    resource.mainAgentId = agentId;
+                }
+                if (agentId !== resource.mainAgentId) {
+                    resource.childAgents.add(agentId);
+                    break;
+                }
+                const promptId = resource.pendingPrompts.shift();
+                if (promptId) {
+                    resource.agentTurns.set(`${agentId}:${turnNumber}`, promptId);
+                    resource.activePromptId = promptId;
+                }
+                break;
+            }
+            case 'prompt.completed':
+            case 'prompt.aborted': {
+                const promptId = typeof payload.promptId === 'string' ? payload.promptId : null;
+                if (!promptId)
+                    break;
+                if (resource.activePromptId === promptId)
+                    resource.activePromptId = null;
+                for (const [binding, bound] of resource.agentTurns) {
+                    if (bound === promptId)
+                        resource.agentTurns.delete(binding);
+                }
+                break;
+            }
+            case 'subagent.spawned':
+                if (typeof payload.subagentId === 'string')
+                    resource.childAgents.add(payload.subagentId);
+                break;
+            case 'agent.status.updated':
+                if (payload.status === 'awaiting_approval')
+                    void this.pollPending(resource, 'approvals');
+                if (payload.status === 'awaiting_question')
+                    void this.pollPending(resource, 'questions');
+                break;
+            default:
+                break;
+        }
+    }
+    async pollPending(resource, list) {
+        if (resource.pollInFlight)
+            return;
+        resource.pollInFlight = list;
+        const kind = list === 'approvals' ? 'approval' : 'question';
+        try {
+            const handle = this.input.servers.get(resource.profileKey);
+            if (!handle)
+                return;
+            const data = await handle.client.get(`/api/v1/sessions/${resource.threadId}/${list}`);
+            const items = list === 'approvals'
+                ? decodeApprovalItems(data).map((item) => ({ kimiId: item.approval_id, item }))
+                : decodeQuestionItems(data).map((item) => ({ kimiId: item.question_id, item }));
+            for (const { kimiId, item } of items) {
+                const known = [...resource.pendingInteractions.values()].some((pending) => pending.kimiId === kimiId);
+                if (known)
+                    continue;
+                const request = list === 'approvals'
+                    ? approvalToServerRequest(++resource.interactionSequence, item)
+                    : questionToServerRequest(++resource.interactionSequence, item);
+                if (!request)
+                    continue;
+                resource.pendingInteractions.set(String(request.id), { kind, kimiId, settling: false });
+                const accepted = await this.input.onServerRequest(resource.sessionId, request, {
+                    kind: 'root',
+                });
+                if (!accepted)
+                    resource.pendingInteractions.delete(String(request.id));
+            }
+        }
+        catch {
+            // Polling is opportunistic; the next status change retries.
+        }
+        finally {
+            resource.pollInFlight = null;
+        }
+    }
+    async resolveInteraction(resource, pending, result) {
+        const handle = this.input.servers.get(resource.profileKey);
+        if (!handle)
+            throw new Error(KIMI_SESSION_NOT_RUNNING);
+        if (pending.kind === 'approval') {
+            const decision = kimiApprovalDecision(result);
+            if (!decision)
+                throw new Error('KIMI_INTERACTION_RESPONSE_INVALID');
+            await handle.client.post(`/api/v1/sessions/${resource.threadId}/approvals/${pending.kimiId}`, { decision });
+            return;
+        }
+        const data = await handle.client.get(`/api/v1/sessions/${resource.threadId}/questions`);
+        const item = decodeQuestionItems(data).find((candidate) => candidate.question_id === pending.kimiId);
+        const answers = item ? kimiQuestionAnswers(item, result) : null;
+        if (!answers)
+            throw new Error('KIMI_INTERACTION_RESPONSE_INVALID');
+        try {
+            await handle.client.post(`/api/v1/sessions/${resource.threadId}/questions/${pending.kimiId}`, { answers });
+        }
+        catch (error) {
+            // A dismissal reports 40909 as its success code; treat it as resolved.
+            if (!(isKimiWebError(error) && error.code === 40909))
+                throw error;
+        }
+    }
+    requireResource(session) {
+        const resource = this.sessions.get(session.id);
+        if (!resource || !session.threadId)
+            throw new Error(KIMI_SESSION_NOT_RUNNING);
+        return resource;
+    }
+    async submitPrompt(resource, promptId, text, model) {
+        const handle = this.input.servers.get(resource.profileKey);
+        if (!handle)
+            throw new Error(KIMI_SESSION_NOT_RUNNING);
+        resource.pendingPrompts.push(promptId);
+        try {
+            await handle.client.post(`/api/v1/sessions/${resource.threadId}/prompts`, {
+                content: [{ type: 'text', text }],
+                prompt_id: promptId,
+                ...(model ? { model } : {}),
+            });
+        }
+        catch (error) {
+            resource.pendingPrompts = resource.pendingPrompts.filter((candidate) => candidate !== promptId);
+            for (const [binding, bound] of resource.agentTurns) {
+                if (bound === promptId)
+                    resource.agentTurns.delete(binding);
+            }
+            if (resource.activePromptId === promptId)
+                resource.activePromptId = null;
+            throw error;
+        }
+        // kimi enqueues prompts submitted while a turn runs; steer pulls the
+        // queued prompt into the active turn instead of deferring it.
+        if (resource.activePromptId) {
+            await handle.client.post(`/api/v1/sessions/${resource.threadId}/prompts:steer`, {
+                prompt_ids: [promptId],
+            });
+        }
+    }
+    async readHistoryFrom(resource) {
+        const handle = this.input.servers.get(resource.profileKey);
+        if (!handle)
+            throw new Error(KIMI_SESSION_NOT_RUNNING);
+        return this.fetchHistory(handle, resource.threadId);
+    }
+    async readDetachedHistory(session) {
+        const handle = await this.ensureServer(session);
+        return this.fetchHistory(handle, session.threadId);
+    }
+    async fetchHistory(handle, threadId) {
+        const [messages, status] = await Promise.all([
+            handle.client.get(`/api/v1/sessions/${threadId}/messages`),
+            handle.client.get(`/api/v1/sessions/${threadId}`),
+        ]);
+        const items = Array.isArray(messages?.items)
+            ? messages.items
+            : [];
+        return {
+            turns: groupMessagesIntoTurns(items),
+            activeTurnId: extractActivePromptId(status),
+        };
+    }
+    async detach(sessionId) {
+        const resource = this.sessions.get(sessionId);
+        if (!resource)
+            return;
+        this.sessions.delete(sessionId);
+        const connection = this.connections.get(resource.profileKey);
+        if (connection) {
+            connection.sessions.delete(sessionId);
+            if (connection.sessions.size === 0) {
+                this.connections.delete(resource.profileKey);
+                connection.eventUnsub();
+                connection.closeUnsub();
+                connection.client.close();
+            }
+            else {
+                void connection.client.unsubscribe([resource.threadId]).catch(() => { });
+            }
+        }
+    }
+}
+function kimiPermissionMode(session) {
+    const policy = session.executionPolicy?.approvalPolicy;
+    if (policy === 'never')
+        return 'yolo';
+    return 'manual';
+}
+function classifyWriterAcquisitionFailure(error) {
+    if (error instanceof WriterAcquisitionError)
+        return error;
+    if (isKimiWebError(error))
+        return new WriterAcquisitionError('runtimeUnavailable');
+    const message = error instanceof Error ? error.message : String(error);
+    if (/ENOENT|spawn|kimi web exited/i.test(message)) {
+        return new WriterAcquisitionError('runtimeDependencyFailed');
+    }
+    return new WriterAcquisitionError('runtimeUnavailable');
+}
+function isKimiSessionMissing(error) {
+    return isKimiWebError(error) && (error.code === 40401 || error.code === 404);
+}
+function extractActivePromptId(status) {
+    const record = status && typeof status === 'object' ? status : null;
+    if (!record || record.main_turn_active !== true)
+        return null;
+    return typeof record.current_prompt_id === 'string' ? record.current_prompt_id : null;
+}
+/** Groups a kimi transcript into relay turns: each user message opens a turn. */
+function groupMessagesIntoTurns(items) {
+    const turns = [];
+    let current = null;
+    for (const message of items.slice(0, 2_000)) {
+        const role = typeof message.role === 'string' ? message.role : null;
+        const content = Array.isArray(message.content) ? message.content : [];
+        const text = content
+            .flatMap((part) => part && typeof part === 'object' && part.type === 'text'
+            ? [String(part.text ?? '')]
+            : [])
+            .join('')
+            .slice(0, 64_000);
+        const id = typeof message.id === 'string' ? message.id : `kimi-message-${turns.length}`;
+        if (role === 'user') {
+            current = { items: [], startedAt: null, completedAt: null };
+            turns.push(current);
+            if (text)
+                current.items.push({ id, kind: 'user', text });
+            continue;
+        }
+        if (!current) {
+            current = { items: [], startedAt: null, completedAt: null };
+            turns.push(current);
+        }
+        if (role === 'assistant' && text) {
+            current.items.push({ id, kind: 'agent', text, phase: 'final_answer' });
+        }
+        else if (role === 'tool') {
+            for (const part of content) {
+                if (part &&
+                    typeof part === 'object' &&
+                    part.type === 'tool_use') {
+                    const tool = part;
+                    current.items.push({
+                        id: typeof tool.tool_call_id === 'string' ? tool.tool_call_id : id,
+                        kind: 'tool',
+                        name: typeof tool.tool_name === 'string' ? tool.tool_name : 'tool',
+                        status: 'completed',
+                    });
+                }
+            }
+        }
+    }
+    return turns;
+}
+function record(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : null;
+}
+function safeTurnNumber(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 ? value : null;
+}
+function agentIdOf(payload) {
+    const value = record(payload);
+    return value && typeof value.agentId === 'string' ? value.agentId : null;
+}
+function turnNumberOf(payload) {
+    const value = record(payload);
+    return value ? safeTurnNumber(value.turnId) : null;
+}