@platless/axom-cli 0.1.0 → 0.5.9

package/dist/workstation/qoderAdapter/foregroundOutput.js

@@ -0,0 +1,36 @@
+export function certifiedRuntime(identity) {
+    return identity?.name === 'qoder-cli' && identity.version === '1.1.61';
+}
+function record(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+export function newForegroundOutputData() {
+    return { pending: {} };
+}
+export class ForegroundOutputBoundary {
+    nativeSessionId;
+    data;
+    constructor(nativeSessionId, data = newForegroundOutputData()) {
+        this.nativeSessionId = nativeSessionId;
+        this.data = data;
+    }
+    accept(event) {
+        if (event.acpSessionId && event.acpSessionId !== this.nativeSessionId)
+            return true;
+        const p = event.payload, input = record(p.rawInput), pending = this.data.pending;
+        if (event.eventName === 'tool_call' && p.kind === 'think' && record(record(p._meta).qoder).toolName === 'Agent' &&
+            typeof p.toolCallId === 'string' && typeof input.prompt === 'string' &&
+            (input.run_in_background === undefined || input.run_in_background === false)) {
+            Object.defineProperty(pending, p.toolCallId, { value: true, enumerable: true, writable: true, configurable: true });
+        }
+        if (event.eventName === 'tool_call_update' && typeof p.toolCallId === 'string' &&
+            ['completed', 'failed', 'cancelled'].includes(String(p.status)) && Object.hasOwn(pending, p.toolCallId))
+            delete pending[p.toolCallId];
+        // Identified/draft child streams and controls keep their existing handling. Never assign an
+        // unaddressed chunk to whichever child happens to finish first.
+        return Object.keys(pending).length === 0 || !['agent_message_chunk', 'agent_thought_chunk'].includes(event.eventName) ||
+            typeof p.messageId === 'string' || p._meta != null;
+    }
+    endTurn() { for (const id of Object.keys(this.data.pending))
+        delete this.data.pending[id]; }
+}

package/dist/workstation/qoderAdapter/history.js

@@ -0,0 +1,85 @@
+const DEFAULT_LIMIT = 50;
+const MAX_LIMIT = 200;
+const MAX_OFFSET = 100_000;
+const MAX_IDS = 4096;
+const DEFAULT_TIMEOUT_MS = 5_000;
+const MAX_TIMEOUT_MS = 30_000;
+const DEFAULT_MAX_BYTES = 4 * 1024 * 1024;
+const MAX_BYTES = 8 * 1024 * 1024;
+const safeIdentity = (value) => typeof value === 'string' &&
+    value.length > 0 && value.length <= 256 && !/[\x00-\x1f\x7f\\/]/.test(value) &&
+    /^[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(value);
+function validDirectory(value) {
+    return typeof value === 'string' && value.length > 0 && value.length <= 4096 &&
+        value.startsWith('/') && !/[\x00-\x1f\x7f]/.test(value) &&
+        !value.replaceAll('\\', '/').split('/').includes('..');
+}
+function unknownResult(rootSessionId, agentId, offset = 0, limit = DEFAULT_LIMIT, reason = 'sdk-error') {
+    return { status: 'unknown', entries: [], rootSessionId, agentId, offset, limit,
+        hasMore: false, snapshotStable: false, reason };
+}
+async function bounded(operation, timeoutMs) {
+    return await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error('history read timed out')), timeoutMs);
+        operation.then(resolve, reject).finally(() => clearTimeout(timer));
+    });
+}
+function normalizeMessage(rootSessionId, agentId, message) {
+    const kind = message.type === 'user' || message.type === 'assistant' || message.type === 'system'
+        ? message.type : 'unknown';
+    const parent = safeIdentity(message.parent_agent_id) ? message.parent_agent_id : undefined;
+    return {
+        kind, id: safeIdentity(message.uuid) ? message.uuid : 'unknown', rootSessionId, agentId,
+        source: 'qoder-sdk', readOnly: true, actions: [], message: message.message,
+        ...(typeof message.timestamp === 'string' ? { timestamp: message.timestamp } : {}),
+        ...(parent ? { parentAgentId: parent } : {}),
+        parentAgentIdStatus: parent ? 'verified' : 'unknown',
+    };
+}
+/**
+ * Reads a bounded, read-only child transcript using only Qoder's public SDK APIs.
+ * `offset` is a page offset, never a durable tail cursor. The SDK may read the full
+ * transcript before applying it; maxBytes bounds returned data, not bytes read on disk.
+ */
+export async function readChildHistory(rootSessionId, agentId, page, reader) {
+    const offset = page?.offset ?? 0;
+    const limit = page?.limit ?? DEFAULT_LIMIT;
+    const timeoutMs = page?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const maxBytes = page?.maxBytes ?? DEFAULT_MAX_BYTES;
+    if (!safeIdentity(rootSessionId) || !safeIdentity(agentId))
+        return unknownResult(rootSessionId, agentId, 0, DEFAULT_LIMIT, 'invalid-identity');
+    if (!validDirectory(page?.dir) || !Number.isSafeInteger(offset) || offset < 0 || offset > MAX_OFFSET ||
+        !Number.isSafeInteger(limit) || limit < 1 || limit > MAX_LIMIT ||
+        !Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > MAX_TIMEOUT_MS ||
+        !Number.isSafeInteger(maxBytes) || maxBytes < 1024 || maxBytes > MAX_BYTES)
+        return unknownResult(rootSessionId, agentId, Number.isSafeInteger(offset) && offset >= 0 ? offset : 0, Number.isSafeInteger(limit) && limit > 0 ? limit : DEFAULT_LIMIT, 'invalid-page');
+    const rosterOptions = { dir: page.dir };
+    const messageOptions = { dir: page.dir, offset, limit };
+    try {
+        const listed = await bounded(reader.listSubagents(rootSessionId, rosterOptions), timeoutMs);
+        if (!Array.isArray(listed) || listed.length > MAX_IDS ||
+            listed.some((id) => !safeIdentity(id)))
+            return unknownResult(rootSessionId, agentId, offset, limit, 'malformed-result');
+        if (!listed.includes(agentId))
+            return unknownResult(rootSessionId, agentId, offset, limit, 'child-not-listed');
+        const messages = await bounded(reader.getSubagentMessages(rootSessionId, agentId, messageOptions), timeoutMs);
+        if (!Array.isArray(messages) || messages.length > limit || messages.length > MAX_IDS)
+            return unknownResult(rootSessionId, agentId, offset, limit, 'malformed-result');
+        if (messages.some((message) => !message || typeof message !== 'object' ||
+            message.session_id !== rootSessionId || !safeIdentity(message.uuid)))
+            return unknownResult(rootSessionId, agentId, offset, limit, 'malformed-result');
+        const entries = messages.map((message) => normalizeMessage(rootSessionId, agentId, message));
+        const serialized = JSON.stringify(entries);
+        if (serialized === undefined || Buffer.byteLength(serialized, 'utf8') > maxBytes)
+            return unknownResult(rootSessionId, agentId, offset, limit, 'oversized-result');
+        // Recheck membership after the read so a changing child roster cannot be presented as stable.
+        const after = await bounded(reader.listSubagents(rootSessionId, rosterOptions), timeoutMs);
+        if (!Array.isArray(after) || !after.includes(agentId))
+            return unknownResult(rootSessionId, agentId, offset, limit, 'snapshot-changed');
+        return { status: 'verified', entries, rootSessionId, agentId, offset, limit,
+            hasMore: messages.length === limit, snapshotStable: true };
+    }
+    catch {
+        return unknownResult(rootSessionId, agentId, offset, limit, 'sdk-error');
+    }
+}

package/dist/workstation/qoderAdapter/identityIndex.js

@@ -0,0 +1,191 @@
+const identifier = (value) => typeof value === 'string' &&
+    value.length > 0 && value.length <= 256 && !/[\x00-\x1f\x7f]/.test(value);
+const copySource = (source) => ({
+    rootSessionId: source.rootSessionId, runtimeGeneration: source.runtimeGeneration,
+    toolUseId: source.toolUseId, sourceId: source.sourceId, runId: source.runId,
+    ...(source.parentToolUseId ? { parentToolUseId: source.parentToolUseId } : {}),
+});
+const copyOrigin = (origin) => ({
+    rootSessionId: origin.rootSessionId,
+    ...(origin.runtimeGeneration !== undefined ? { runtimeGeneration: origin.runtimeGeneration } : {}),
+    ...(origin.agentId !== undefined ? { agentId: origin.agentId } : {}),
+    ...(origin.taskId !== undefined ? { taskId: origin.taskId } : {}),
+    ...(origin.toolUseId !== undefined ? { toolUseId: origin.toolUseId } : {}),
+    ...(origin.launchingToolUseId !== undefined ? { launchingToolUseId: origin.launchingToolUseId } : {}),
+});
+export class IdentityIndex {
+    options;
+    binding;
+    entries = new Map();
+    launches = new Map();
+    agents = new Map();
+    closed = false;
+    maximum;
+    constructor(binding, options = {}) {
+        this.options = options;
+        if (!identifier(binding.rootSessionId) || !identifier(binding.runtimeGeneration))
+            throw new Error('Invalid observer binding');
+        this.binding = { rootSessionId: binding.rootSessionId, runtimeGeneration: binding.runtimeGeneration };
+        const maximum = options.maxBindings ?? 4096;
+        if (!Number.isSafeInteger(maximum) || maximum < 1)
+            throw new Error('Invalid observer capacity');
+        this.maximum = Math.min(4096, maximum);
+    }
+    accepts(origin) {
+        return !this.closed && origin.rootSessionId === this.binding.rootSessionId &&
+            origin.runtimeGeneration === this.binding.runtimeGeneration;
+    }
+    entry(id) {
+        if (!identifier(id))
+            return undefined;
+        let entry = this.entries.get(id);
+        if (!entry) {
+            if (this.entries.size >= this.maximum) {
+                this.options.onDegraded?.('capacity');
+                return undefined;
+            }
+            entry = {};
+            this.entries.set(id, entry);
+        }
+        return entry;
+    }
+    publish(entry) {
+        if (!entry.source || (!entry.origin && !entry.revoked))
+            return;
+        const origin = entry.revoked ? null : copyOrigin(entry.origin);
+        const key = JSON.stringify([origin, entry.revoked]);
+        if (entry.emitted === key)
+            return;
+        entry.emitted = key;
+        this.options.onCorrection?.({ binding: copySource(entry.source), origin,
+            ...(entry.revoked ? { reason: entry.revoked } : {}) });
+    }
+    revoke(entry, reason) {
+        if (!entry.revoked) {
+            entry.revoked = reason;
+            this.options.onDegraded?.(reason);
+        }
+        this.publish(entry);
+    }
+    registerTool(source) {
+        if (!this.accepts(source) || !identifier(source.sourceId) || !identifier(source.runId))
+            return;
+        const entry = this.entry(source.toolUseId);
+        if (!entry)
+            return;
+        if (entry.source && (entry.source.sourceId !== source.sourceId || entry.source.runId !== source.runId)) {
+            this.revoke(entry, 'source-conflict');
+            return;
+        }
+        entry.source ??= copySource(source);
+        this.publish(entry);
+    }
+    joinLaunch(agentId, launchingToolUseId) {
+        const prior = this.agents.get(agentId);
+        const priorAgent = this.launches.get(launchingToolUseId);
+        if ((!this.agents.has(agentId) && this.agents.size >= this.maximum) ||
+            (!this.launches.has(launchingToolUseId) && this.launches.size >= this.maximum)) {
+            this.options.onDegraded?.('capacity');
+            this.observeConflict({ ...this.binding, agentId, launchingToolUseId });
+            return false;
+        }
+        if ((prior !== undefined && prior !== launchingToolUseId) ||
+            (priorAgent !== undefined && priorAgent !== agentId)) {
+            this.observeConflict({ ...this.binding, agentId, launchingToolUseId });
+            if (prior)
+                this.observeConflict({ ...this.binding, launchingToolUseId: prior });
+            return false;
+        }
+        this.launches.set(launchingToolUseId, agentId);
+        this.agents.set(agentId, launchingToolUseId);
+        return true;
+    }
+    observe(origin) {
+        if (!this.accepts(origin) || !identifier(origin.agentId))
+            return;
+        if (!origin.toolUseId && identifier(origin.launchingToolUseId)) {
+            if (!this.joinLaunch(origin.agentId, origin.launchingToolUseId))
+                return;
+            for (const entry of this.entries.values()) {
+                if (!entry.origin?.agentId || !this.agents.has(entry.origin.agentId))
+                    continue;
+                const launch = this.agents.get(entry.origin.agentId);
+                if (launch === null)
+                    this.revoke(entry, 'identity-conflict');
+                else {
+                    entry.origin = { ...entry.origin, launchingToolUseId: launch };
+                    this.publish(entry);
+                }
+            }
+            return;
+        }
+        if (!identifier(origin.toolUseId))
+            return;
+        const entry = this.entry(origin.toolUseId);
+        if (!entry || entry.revoked)
+            return;
+        if (origin.launchingToolUseId !== undefined &&
+            (!identifier(origin.launchingToolUseId) || !this.joinLaunch(origin.agentId, origin.launchingToolUseId))) {
+            this.revoke(entry, 'identity-conflict');
+            return;
+        }
+        const launch = this.agents.get(origin.agentId);
+        if (launch === null || (entry.origin && entry.origin.agentId !== origin.agentId) ||
+            (entry.origin?.launchingToolUseId && launch && entry.origin.launchingToolUseId !== launch)) {
+            this.revoke(entry, 'identity-conflict');
+            return;
+        }
+        if (origin.launchingToolUseId !== undefined && (!identifier(origin.launchingToolUseId) ||
+            this.launches.get(origin.launchingToolUseId) === null ||
+            (entry.origin?.launchingToolUseId !== undefined && entry.origin.launchingToolUseId !== origin.launchingToolUseId) ||
+            (launch !== undefined && launch !== origin.launchingToolUseId))) {
+            this.revoke(entry, 'identity-conflict');
+            return;
+        }
+        const launchingToolUseId = launch ?? origin.launchingToolUseId ?? entry.origin?.launchingToolUseId;
+        entry.origin = { ...this.binding, toolUseId: origin.toolUseId, agentId: origin.agentId,
+            ...(launchingToolUseId ? { launchingToolUseId } : {}) };
+        this.publish(entry);
+    }
+    observeConflict(origin) {
+        if (!this.accepts(origin))
+            return;
+        if (identifier(origin.toolUseId)) {
+            const entry = this.entry(origin.toolUseId);
+            if (entry)
+                this.revoke(entry, 'identity-conflict');
+        }
+        if (identifier(origin.agentId)) {
+            if (this.agents.has(origin.agentId) || this.agents.size < this.maximum)
+                this.agents.set(origin.agentId, null);
+            for (const entry of this.entries.values()) {
+                if (entry.origin?.agentId === origin.agentId)
+                    this.revoke(entry, 'identity-conflict');
+            }
+        }
+        if (!identifier(origin.launchingToolUseId))
+            return;
+        const agent = this.launches.get(origin.launchingToolUseId);
+        if (!this.launches.has(origin.launchingToolUseId) && this.launches.size >= this.maximum) {
+            this.options.onDegraded?.('capacity');
+            return;
+        }
+        if (this.launches.get(origin.launchingToolUseId) !== null)
+            this.options.onDegraded?.('identity-conflict');
+        this.launches.set(origin.launchingToolUseId, null);
+        if (agent)
+            this.agents.set(agent, null);
+        for (const entry of this.entries.values()) {
+            if ((agent && entry.origin?.agentId === agent) || entry.origin?.launchingToolUseId === origin.launchingToolUseId) {
+                this.revoke(entry, 'identity-conflict');
+            }
+        }
+    }
+    resolveTool(rootSessionId, toolUseId) {
+        if (this.closed || rootSessionId !== this.binding.rootSessionId)
+            return undefined;
+        const entry = this.entries.get(toolUseId);
+        return entry?.origin && !entry.revoked ? copyOrigin(entry.origin) : undefined;
+    }
+    dispose() { this.closed = true; this.entries.clear(); this.launches.clear(); this.agents.clear(); }
+}

package/dist/workstation/qoderAdapter/inputQueue.js

@@ -0,0 +1,42 @@
+export class InputQueue {
+    capacity;
+    values = [];
+    waiting;
+    closed = false;
+    constructor(capacity = 32) {
+        this.capacity = capacity;
+        if (!Number.isSafeInteger(capacity) || capacity < 1 || capacity > 1024)
+            throw new Error('Invalid input capacity');
+    }
+    push(value) {
+        if (this.closed)
+            throw new Error('Input queue closed');
+        if (this.waiting) {
+            const waiting = this.waiting;
+            this.waiting = undefined;
+            waiting({ done: false, value });
+        }
+        else {
+            if (this.values.length >= this.capacity)
+                throw new Error('Input queue capacity exceeded');
+            this.values.push(value);
+        }
+    }
+    close() {
+        this.closed = true;
+        this.values = [];
+        this.waiting?.({ done: true, value: undefined });
+        this.waiting = undefined;
+    }
+    next() {
+        if (this.closed)
+            return Promise.resolve({ done: true, value: undefined });
+        if (this.values.length)
+            return Promise.resolve({ done: false, value: this.values.shift() });
+        if (this.waiting)
+            return Promise.reject(new Error('Input queue already has a reader'));
+        return new Promise((resolve) => { this.waiting = resolve; });
+    }
+    return() { this.close(); return this.next(); }
+    [Symbol.asyncIterator]() { return this; }
+}

package/dist/workstation/qoderAdapter/main.js

@@ -0,0 +1,95 @@
+import { agent, methods, PROTOCOL_VERSION, RequestError, ndJsonStream } from '@agentclientprotocol/sdk';
+import { Readable, Writable } from 'node:stream';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { loadSdkDriver } from './sdkDriver.js';
+import { loadPreparedSdkRuntime } from './sdkRuntime.js';
+import { QoderAdapterSession } from './session.js';
+import { supportsQoderSdkSteering } from './sdkDriver.js';
+const stopRequest = (value) => {
+    if (!value || typeof value !== 'object' || Array.isArray(value) ||
+        ['sessionId', 'taskId', 'requestId'].some((key) => typeof value[key] !== 'string'))
+        throw RequestError.invalidParams('Invalid provider task stop request');
+    return value;
+};
+const steeringRequest = (value) => {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw RequestError.invalidParams('Invalid Qoder steering request');
+    const input = value;
+    if (typeof input.sessionId !== 'string' || !input.sessionId.trim() || !Array.isArray(input.prompt) || input.prompt.length === 0)
+        throw RequestError.invalidParams('Invalid Qoder steering request');
+    const meta = input._meta;
+    const steering = meta && typeof meta === 'object' && !Array.isArray(meta) ? meta.steering : undefined;
+    const priority = steering && typeof steering === 'object' && !Array.isArray(steering) ? steering.priority : undefined;
+    if (priority !== undefined && priority !== 'now')
+        throw RequestError.invalidParams('Qoder steering only supports priority now');
+    return { sessionId: input.sessionId, prompt: input.prompt, priority: priority };
+};
+export function createQoderAgent(options) {
+    let connection;
+    let opened = false;
+    let profileRevision = 0;
+    const session = new QoderAdapterSession({ ...options,
+        update: (value) => connection.client.notify(methods.client.session.update, value),
+        profile: (value) => connection?.signal.aborted ? Promise.resolve() :
+            connection.client.notify('_axom/qoder/profile', { sessionId: value.rootSessionId,
+                revision: ++profileRevision, profile: value }),
+        permission: (request, signal) => connection.client.request(methods.client.session.requestPermission, request, { cancellationSignal: signal }),
+        taskObservation: (value) => connection.client.notify('_qoder/task_event', value) });
+    const close = () => session.close();
+    const app = agent({ name: 'axom-qoder-sdk' })
+        .onConnect((value) => {
+        if (connection) {
+            if (connection.signal !== value.signal)
+                value.close(new Error('Adapter permits one connection'));
+            return;
+        }
+        connection = value;
+        value.signal.addEventListener('abort', () => { void close().catch(() => { }); }, { once: true });
+    })
+        .onRequest(methods.agent.initialize, () => ({ protocolVersion: PROTOCOL_VERSION,
+        agentInfo: { name: 'axom-qoder-sdk', version: '1.0.50' },
+        agentCapabilities: { loadSession: false, promptCapabilities: { image: false, audio: false, embeddedContext: false } },
+        authMethods: [], _meta: { qoderProfile: {
+                cliVersion: options.driver.cliVersion, sdkVersion: options.driver.sdkVersion, mode: 'sdk-adapter',
+                executable: options.driver.executable, persistent: true, transport: 'process', capabilities: [],
+                agentMessaging: false, observerHealthy: false, initialized: false, rootConfirmed: false,
+                completedContinuationEnabled: false, sendMessageExposed: false, platform: process.platform,
+                runtimeSource: 'explicit-local'
+            },
+            ...(supportsQoderSdkSteering(options.driver.cliVersion) ? { steering: { supported: true, timings: ['now'] } } : {}) } }))
+        .onRequest(methods.agent.session.new, async (ctx) => {
+        if (opened)
+            throw RequestError.invalidParams('Adapter permits one session');
+        opened = true;
+        return session.newSession(ctx.params);
+    })
+        .onRequest(methods.agent.session.prompt, (ctx) => session.prompt(ctx.params))
+        .onRequest('_session/steering', steeringRequest, (ctx) => {
+        if (ctx.params.sessionId !== session.currentProfile?.rootSessionId)
+            return { outcome: 'promptRequired' };
+        return session.steer(ctx.params.prompt, ctx.params.priority).then((outcome) => ({ outcome }));
+    })
+        .onRequest('_axom/task/stop', stopRequest, (ctx) => session.stopTask(ctx.params))
+        .onNotification(methods.agent.session.cancel, async (ctx) => {
+        if (ctx.params.sessionId !== session.currentProfile?.rootSessionId)
+            return;
+        await session.cancel();
+    });
+    return { app, close };
+}
+export async function runQoderAdapter(executable) {
+    const { sdk } = await loadPreparedSdkRuntime();
+    const driver = await loadSdkDriver(executable, sdk);
+    const runDir = await mkdtemp(join(tmpdir(), 'axom-qoder-acp-'));
+    const server = createQoderAgent({ driver, runDir, historyReader: sdk });
+    try {
+        const connection = server.app.connect(ndJsonStream(Writable.toWeb(process.stdout), Readable.toWeb(process.stdin)));
+        await connection.closed;
+    }
+    finally {
+        await server.close();
+        await rm(runDir, { recursive: true, force: true });
+    }
+}

package/dist/workstation/qoderAdapter/mapper.js

@@ -0,0 +1,117 @@
+import { IdentityIndex } from './identityIndex.js';
+import { qoderChildMeta, qoderCorrectionMeta, qoderSpawnMeta } from './subagentMeta.js';
+const id = (value) => typeof value === 'string' && value.length > 0 &&
+    value.length <= 256 && !/[\x00-\x1f\x7f]/.test(value);
+export class QoderMessageMapper {
+    options;
+    binding;
+    sources = new Map();
+    conflictedTools = new Set();
+    messages = new Set();
+    index;
+    collecting;
+    closed = false;
+    constructor(binding, options = {}) {
+        this.options = options;
+        this.binding = { rootSessionId: binding.rootSessionId, runtimeGeneration: binding.runtimeGeneration };
+        this.index = new IdentityIndex(this.binding, { onDegraded: options.degraded, onCorrection: ({ binding: source, origin }) => {
+                const update = { sessionUpdate: 'tool_call_update', toolCallId: source.toolUseId,
+                    _meta: { qoderSdk: { version: 1, source, origin, originCleared: origin === null },
+                        ...qoderCorrectionMeta(source, origin) } };
+                if (this.collecting)
+                    this.collecting.push(update);
+                else
+                    options.correction?.(update);
+            } });
+    }
+    map(message, runId) {
+        if (this.closed || message.session_id !== this.binding.rootSessionId ||
+            (message.type === 'user' && 'isReplay' in message && message.isReplay))
+            return [];
+        if (message.type !== 'assistant' && message.type !== 'user')
+            return [];
+        if (!id(message.uuid)) {
+            this.options.degraded?.('message-identity');
+            return [];
+        }
+        if (this.messages.has(message.uuid))
+            return [];
+        if (this.messages.size >= 4096) {
+            this.options.degraded?.('mapper-capacity');
+            return [];
+        }
+        this.messages.add(message.uuid);
+        const updates = [];
+        this.collecting = updates;
+        try {
+            const blocks = message.message.content;
+            if (!Array.isArray(blocks))
+                return [];
+            for (const block of blocks) {
+                if (message.type === 'assistant' && (block.type === 'text' || block.type === 'thinking')) {
+                    const text = block.type === 'thinking' ? block.thinking : block.text;
+                    const parentToolUseId = message.parent_tool_use_id;
+                    if (typeof text === 'string' && Buffer.byteLength(text) <= 131072) {
+                        if (parentToolUseId !== null && (!id(parentToolUseId) || this.conflictedTools.has(parentToolUseId))) {
+                            this.options.degraded?.('child-message-unscoped');
+                            continue;
+                        }
+                        updates.push({ sessionUpdate: block.type === 'text' ? 'agent_message_chunk' : 'agent_thought_chunk',
+                            content: { type: 'text', text },
+                            ...(parentToolUseId ? { _meta: qoderChildMeta(parentToolUseId, this.index.resolveTool(this.binding.rootSessionId, parentToolUseId), { source: 'sdk' }) } : {}) });
+                    }
+                }
+                else if (message.type === 'assistant' && block.type === 'tool_use' && id(block.id) && id(block.name)) {
+                    const parentToolUseId = message.parent_tool_use_id;
+                    const ownerRun = parentToolUseId && !this.conflictedTools.has(parentToolUseId)
+                        ? this.sources.get(parentToolUseId)?.runId : parentToolUseId ? undefined : runId;
+                    if (!id(ownerRun)) {
+                        this.options.degraded?.('tool-run-unbound');
+                        continue;
+                    }
+                    const source = { ...this.binding, toolUseId: block.id, sourceId: message.uuid, runId: ownerRun,
+                        ...(parentToolUseId ? { parentToolUseId } : {}) };
+                    const existing = this.sources.get(block.id);
+                    if (existing) {
+                        this.conflictedTools.add(block.id);
+                        this.index.registerTool(source);
+                        this.options.degraded?.('tool-id-reused');
+                        continue;
+                    }
+                    if (this.sources.size >= 4096) {
+                        this.options.degraded?.('mapper-capacity');
+                        continue;
+                    }
+                    this.sources.set(block.id, source);
+                    const qoder = parentToolUseId && !this.conflictedTools.has(parentToolUseId)
+                        ? qoderChildMeta(parentToolUseId, this.index.resolveTool(this.binding.rootSessionId, block.id), { source: 'sdk', toolUseId: block.id, toolName: block.name })
+                        : !parentToolUseId && block.name === 'Agent' ? qoderSpawnMeta(block.id) : undefined;
+                    updates.push({ sessionUpdate: 'tool_call', toolCallId: block.id, name: block.name, title: block.name,
+                        kind: block.name === 'Agent' ? 'think' : block.name === 'Read' ? 'read' : block.name === 'Edit' ? 'edit' : block.name === 'Bash' ? 'execute' : 'other',
+                        status: 'in_progress', rawInput: block.input,
+                        _meta: { qoderSdk: { version: 1, source, toolName: block.name }, ...(qoder ?? {}) } });
+                    this.index.registerTool(source);
+                }
+                else if (message.type === 'user' && block.type === 'tool_result' && id(block.tool_use_id) &&
+                    this.sources.has(block.tool_use_id) && !this.conflictedTools.has(block.tool_use_id)) {
+                    const source = this.sources.get(block.tool_use_id);
+                    const qoder = source.parentToolUseId
+                        ? qoderChildMeta(source.parentToolUseId, this.index.resolveTool(this.binding.rootSessionId, block.tool_use_id), { source: 'sdk', toolUseId: block.tool_use_id })
+                        : undefined;
+                    updates.push({ sessionUpdate: 'tool_call_update', toolCallId: block.tool_use_id,
+                        status: block.is_error ? 'failed' : 'completed', rawOutput: block.content,
+                        _meta: { qoderSdk: { version: 1, source }, ...(qoder ?? {}) } });
+                }
+            }
+            return updates;
+        }
+        finally {
+            this.collecting = undefined;
+        }
+    }
+    observe(origin) { if (!this.closed)
+        this.index.observe(origin); }
+    conflict(origin) { if (!this.closed)
+        this.index.observeConflict(origin); }
+    dispose() { this.closed = true; this.index.dispose(); this.sources.clear(); this.conflictedTools.clear(); this.messages.clear(); }
+}