@platless/axom-cli 0.5.9 → 0.6.36

package/dist/workstation/qoderAdapter/subwork.js

@@ -1,85 +0,0 @@
-const object = (v) => v && typeof v === 'object' && !Array.isArray(v) ? v : {};
-const id = (v) => typeof v === 'string' && v.length > 0 && v.length <= 256 && !/[\x00-\x1f\x7f]/.test(v);
-export function newSubworkData() {
-    return { calls: {}, count: 0 };
-}
-export function supportsSubworkMeta(info) {
-    return (info?.name === 'qoder-cli' && info.version === '1.1.61') ||
-        (info?.name === 'axom-qoder-sdk' && info.version === '1.0.50');
-}
-function resultText(value) {
-    if (typeof value === 'string')
-        return value;
-    if (Array.isArray(value)) {
-        const texts = value.filter(v => object(v).type === 'text').map(v => object(v).text).filter(v => typeof v === 'string');
-        return texts.length ? texts.join('\n') : undefined;
-    }
-    const v = object(value);
-    if (v.kind === 'agent-result')
-        return resultText(v.content ?? v.result);
-    return undefined;
-}
-export class SubworkBoundary {
-    root;
-    data;
-    constructor(root, data = newSubworkData()) {
-        this.root = root;
-        this.data = data;
-    }
-    get(toolId) { return Object.hasOwn(this.data.calls, toolId) ? this.data.calls[toolId] : undefined; }
-    child(toolId) { return `qoder-agent:${this.root}:${toolId}`; }
-    map(event) {
-        if (event.acpSessionId && event.acpSessionId !== this.root)
-            return [event];
-        const p = event.payload, q = object(object(p._meta).qoder), input = object(p.rawInput);
-        const marked = q.version === 1 && ['native-acp-patch', 'sdk', 'correction'].includes(String(q.source));
-        const toolId = p.toolCallId;
-        let call = id(toolId) ? this.get(toolId) : undefined;
-        const parent = marked && q.route !== 'unknown' && id(q.parentToolUseId) ? q.parentToolUseId : undefined;
-        const events = [];
-        if (!call && marked && p.kind === 'think' && q.toolName === 'Agent' && id(toolId) &&
-            typeof input.prompt === 'string' && (input.subagent_type == null || typeof input.subagent_type === 'string') &&
-            (input.run_in_background === undefined || typeof input.run_in_background === 'boolean') &&
-            ['tool_call', 'tool_call_update'].includes(event.eventName) && this.data.count < 4096) {
-            call = { child: this.child(toolId), ...(parent ? { parent: this.child(parent) } : {}),
-                background: input.run_in_background === true, ended: false, streamedText: '' };
-            Object.defineProperty(this.data.calls, toolId, { value: call, enumerable: true, writable: true, configurable: true });
-            this.data.count += 1;
-            events.push({ eventName: 'subagent_spawned', payload: { subagentSessionId: call.child,
-                    name: typeof input.description === 'string' && input.description.trim() ? input.description : input.subagent_type ?? 'Agent',
-                    task: input.prompt, capabilities: {} }, ...(call.parent ? { acpSessionId: call.parent } : {}) });
-            events.push({ eventName: 'user_message_chunk', payload: { content: { type: 'text', text: input.prompt } }, acpSessionId: call.child });
-        }
-        if (call && ['tool_call', 'tool_call_update'].includes(event.eventName)) {
-            if (call.ended)
-                return events;
-            const output = object(p.rawOutput);
-            const state = output.kind === 'agent-result' ? output.state : undefined;
-            const terminal = state === 'completed' ? 'completed' : ['error', 'failed'].includes(String(state)) ? 'failed' :
-                state === 'cancelled' ? 'cancelled' : ['failed', 'cancelled'].includes(String(p.status)) ? p.status :
-                    !call.background && p.status === 'completed' ? 'completed' : undefined;
-            if (terminal) {
-                const text = resultText(p.rawOutput);
-                if (text !== undefined && !call.streamedText.endsWith(text))
-                    events.push({ eventName: 'agent_message_chunk',
-                        payload: { content: { type: 'text', text } }, acpSessionId: call.child });
-                events.push({ eventName: 'subagent_state_update', payload: { subagentSessionId: call.child, state: terminal },
-                    ...(call.parent ? { acpSessionId: call.parent } : {}) });
-                call.ended = true;
-                // Read only by the check above, once: an ended call keeps no stream (checkpointed state).
-                call.streamedText = '';
-            }
-            // The Agent invocation becomes a dispatch/result in subwork. Keeping the vendor tool here
-            // would also create the old delegation card for the very same task.
-            return events;
-        }
-        if (parent) {
-            const owner = this.get(parent), content = object(p.content);
-            if (owner && !owner.ended && event.eventName === 'agent_message_chunk' && content.type === 'text' && typeof content.text === 'string') {
-                owner.streamedText += content.text;
-            }
-            return [{ ...event, acpSessionId: this.child(parent) }];
-        }
-        return [event];
-    }
-}

package/dist/workstation/qoderAdapter/taskControl.js

@@ -1,38 +0,0 @@
-import { capabilitiesFor } from './profile.js';
-const validId = (value) => value.length > 0 && Buffer.byteLength(value, 'utf8') <= 256 &&
-    !/[\x00-\x1f\x7f]/.test(value);
-export class TaskControl {
-    ledger;
-    profile;
-    query;
-    certifications;
-    binding;
-    requests = new Map();
-    constructor(ledger, profile, query, certifications, binding) {
-        this.ledger = ledger;
-        this.profile = profile;
-        this.query = query;
-        this.certifications = certifications;
-        this.binding = binding;
-    }
-    async stop(request) {
-        if (![request.sessionId, request.taskId, request.requestId].every(validId))
-            throw new Error('Invalid task stop identity');
-        const previous = this.requests.get(request.requestId);
-        if (previous) {
-            if (previous.sessionId !== request.sessionId || previous.taskId !== request.taskId)
-                throw new Error('Task stop request identity conflict');
-            return previous.receipt;
-        }
-        const profile = this.profile(), task = this.ledger.get(request.taskId);
-        if (!profile || !task || request.sessionId !== profile.rootSessionId ||
-            !task.origin.agentId || !task.origin.launchingToolUseId || task.taskType !== 'local_agent' ||
-            task.background !== true || !capabilitiesFor(profile, task, this.certifications, this.binding).stopActiveRun)
-            throw new Error('Task stop unavailable');
-        if (this.requests.size >= 4096)
-            throw new Error('Task stop receipt capacity exceeded');
-        const receipt = this.query.stopTask(request.taskId).then(() => ({ requestId: request.requestId, state: 'accepted' }), () => ({ requestId: request.requestId, state: 'unknown' }));
-        this.requests.set(request.requestId, { sessionId: request.sessionId, taskId: request.taskId, receipt });
-        return receipt;
-    }
-}

package/dist/workstation/qoderAdapter/taskLedger.js

@@ -1,163 +0,0 @@
-const identifier = (value) => typeof value === 'string' && value.length > 0 &&
-    Buffer.byteLength(value, 'utf8') <= 256 && !/[\x00-\x1f\x7f]/.test(value);
-const terminal = (state) => state === 'completed' || state === 'failed' || state === 'stopped';
-const defaultMaxTasks = 4096;
-const sameTask = (a, b) => a.state === b.state && a.live === b.live && a.stale === b.stale && a.taskType === b.taskType &&
-    a.background === b.background && JSON.stringify(a.origin) === JSON.stringify(b.origin);
-export class TaskLedger {
-    rootSessionId;
-    runtimeGeneration;
-    maxTasks;
-    tasks = new Map();
-    seen = new Set();
-    actors = new Map();
-    launchTasks = new Map();
-    conflicts = new Set();
-    notified = new Set();
-    failed = false;
-    constructor(rootSessionId, runtimeGeneration, maxTasks = defaultMaxTasks) {
-        this.rootSessionId = rootSessionId;
-        this.runtimeGeneration = runtimeGeneration;
-        this.maxTasks = maxTasks;
-        if (!identifier(rootSessionId) || !identifier(runtimeGeneration))
-            throw new Error('Invalid task ledger binding');
-        if (!Number.isInteger(maxTasks) || maxTasks < 1 || maxTasks > defaultMaxTasks)
-            throw new Error('Invalid task ledger capacity');
-    }
-    get(taskId) {
-        const task = this.tasks.get(taskId);
-        return task && { ...task, origin: { ...task.origin } };
-    }
-    all() { return [...this.tasks.keys()].map((id) => this.get(id)); }
-    get launchObservationCount() { return this.actors.size; }
-    get degraded() { return this.failed; }
-    markStale() {
-        for (const [id, task] of this.tasks)
-            this.tasks.set(id, { ...task, live: false, stale: true });
-        return this.all();
-    }
-    degrade() {
-        this.failed = true;
-        return this.markStale();
-    }
-    observeLaunch(toolUseId, agentId) {
-        if (this.failed || !identifier(toolUseId) || !identifier(agentId))
-            return [];
-        const prior = this.actors.get(toolUseId);
-        if (prior !== undefined && prior !== agentId)
-            this.actors.set(toolUseId, null);
-        else if (prior === undefined && this.actors.size < this.maxTasks)
-            this.actors.set(toolUseId, agentId);
-        const changed = [];
-        for (const [id, task] of this.tasks) {
-            if (task.origin.launchingToolUseId !== toolUseId)
-                continue;
-            const actor = this.actors.get(toolUseId);
-            const next = { ...task, origin: { ...task.origin,
-                    agentId: this.conflicts.has(id) ? undefined : actor ?? undefined },
-                stale: actor === null || this.conflicts.has(id) || task.stale };
-            this.tasks.set(id, next);
-            changed.push(next);
-        }
-        return changed;
-    }
-    ensure(taskId) {
-        if (!identifier(taskId))
-            return undefined;
-        const existing = this.tasks.get(taskId);
-        if (existing)
-            return existing;
-        if (this.tasks.size >= this.maxTasks) {
-            this.degrade();
-            return undefined;
-        }
-        const task = { origin: { rootSessionId: this.rootSessionId, runtimeGeneration: this.runtimeGeneration,
-                taskId }, state: 'unknown', live: false, stale: false };
-        this.tasks.set(taskId, task);
-        return task;
-    }
-    apply(message) {
-        if (this.failed || message.type !== 'system' || message.session_id !== this.rootSessionId ||
-            !identifier(message.uuid) || this.seen.has(message.uuid))
-            return [];
-        if (this.seen.size >= this.maxTasks * 4)
-            return this.degrade();
-        if (message.subtype === 'background_tasks_changed' && message.tasks.length > this.maxTasks)
-            return this.degrade();
-        if (message.subtype === 'background_tasks_changed') {
-            const added = new Set();
-            for (const entry of message.tasks) {
-                if (identifier(entry.task_id) && !this.tasks.has(entry.task_id))
-                    added.add(entry.task_id);
-                if (this.tasks.size + added.size > this.maxTasks)
-                    return this.degrade();
-            }
-        }
-        const previous = new Map(this.tasks);
-        this.seen.add(message.uuid);
-        if (message.subtype === 'background_tasks_changed') {
-            const current = new Map(message.tasks.filter((entry) => identifier(entry.task_id))
-                .map((entry) => [entry.task_id, entry]));
-            for (const [id, task] of this.tasks) {
-                if (!terminal(task.state) && task.background) {
-                    const next = { ...task, live: current.has(id),
-                        stale: current.has(id) ? this.conflicts.has(id) : task.stale };
-                    if (!sameTask(task, next))
-                        this.tasks.set(id, next);
-                }
-            }
-            for (const [id, entry] of current) {
-                const task = this.ensure(id);
-                if (task && !terminal(task.state)) {
-                    const next = { ...task, state: 'running', live: true,
-                        stale: this.conflicts.has(id), taskType: entry.task_type, background: true };
-                    if (!sameTask(task, next))
-                        this.tasks.set(id, next);
-                }
-            }
-        }
-        else if (message.subtype === 'task_started' || message.subtype === 'task_progress') {
-            const task = this.ensure(message.task_id);
-            if (task && !terminal(task.state)) {
-                const toolId = identifier(message.tool_use_id) ? message.tool_use_id : task.origin.launchingToolUseId;
-                if (toolId && !this.launchTasks.has(toolId) && this.launchTasks.size < this.maxTasks)
-                    this.launchTasks.set(toolId, message.task_id);
-                else if (toolId && this.launchTasks.get(toolId) !== message.task_id) {
-                    this.conflicts.add(message.task_id);
-                    const other = this.launchTasks.get(toolId);
-                    if (other) {
-                        this.conflicts.add(other);
-                        const previous = this.tasks.get(other);
-                        if (previous)
-                            this.tasks.set(other, { ...previous, stale: true,
-                                origin: { ...previous.origin, agentId: undefined } });
-                    }
-                }
-                const actor = toolId && this.actors.get(toolId);
-                this.tasks.set(message.task_id, { ...task, state: 'running', stale: this.conflicts.has(message.task_id),
-                    taskType: 'task_type' in message ? message.task_type : task.taskType,
-                    origin: { ...task.origin, launchingToolUseId: toolId,
-                        agentId: this.conflicts.has(message.task_id) ? undefined : actor ?? task.origin.agentId } });
-            }
-        }
-        else if (message.subtype === 'task_updated') {
-            const task = this.ensure(message.task_id);
-            if (task && !terminal(task.state)) {
-                const status = message.patch.status;
-                const state = status === 'killed' ? 'stopped' : status ?? task.state;
-                this.tasks.set(message.task_id, { ...task, state, live: terminal(state) ? false : task.live,
-                    stale: this.conflicts.has(message.task_id), background: message.patch.is_backgrounded ?? task.background });
-            }
-        }
-        else if (message.subtype === 'task_notification') {
-            const task = this.ensure(message.task_id);
-            if (task && (!this.notified.has(message.task_id) ||
-                (task.state === 'stopped' && message.status === 'completed'))) {
-                this.notified.add(message.task_id);
-                this.tasks.set(message.task_id, { ...task, state: message.status,
-                    live: false, stale: this.conflicts.has(message.task_id) });
-            }
-        }
-        return [...this.tasks].filter(([id, task]) => task !== previous.get(id)).map(([id]) => this.get(id));
-    }
-}

package/dist/workstation/qoderAdapter/usage.js

@@ -1,37 +0,0 @@
-export const QODER_CREDITS_LABEL = 'Qoder Credits（厂商报告）';
-const validCredits = (value) => typeof value === 'number' &&
-    Number.isFinite(value) && value >= 0;
-/** Qoder's report is cumulative. A missing/invalid report never erases a prior valid value. */
-export function applyCredits(previous, reported) {
-    if (validCredits(reported))
-        return reported;
-    return validCredits(previous) ? previous : undefined;
-}
-function reportedCredits(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        return undefined;
-    const input = value;
-    for (const key of ['total_credits', 'totalCredits', 'credits'])
-        if (validCredits(input[key]))
-            return input[key];
-    return undefined;
-}
-/**
- * Keeps vendor credits separate from ACP token/USD counters. Qoder's SDK does not
- * provide equivalent token or USD values, so zero placeholders are intentionally omitted.
- */
-export function normalizeQoderUsage(value, previousCredits) {
-    const input = value && typeof value === 'object' && !Array.isArray(value)
-        ? value : {};
-    const scope = input.cumulativeScope === 'unknown' ? 'unknown' : 'session';
-    const reported = reportedCredits(value);
-    if (scope === 'unknown') {
-        return { credits: undefined, creditsLabel: QODER_CREDITS_LABEL, creditsScope: scope,
-            inputTokens: undefined, outputTokens: undefined, costUsd: undefined,
-            ...(validCredits(previousCredits) ? { previousCredits } : {}) };
-    }
-    const credits = applyCredits(previousCredits, reported);
-    return { credits, creditsLabel: QODER_CREDITS_LABEL, creditsScope: scope,
-        inputTokens: undefined, outputTokens: undefined, costUsd: undefined,
-        ...(validCredits(previousCredits) ? { previousCredits } : {}) };
-}