@platless/axom-cli 0.5.9 → 0.6.52

package/dist/workstation/qoderAdapter/foregroundOutput.js

@@ -1,36 +0,0 @@
-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

@@ -1,85 +0,0 @@
-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

@@ -1,191 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,95 +0,0 @@
-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

@@ -1,117 +0,0 @@
-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(); }
-}