actoviq-agent-sdk 0.2.0 → 0.3.0

package/dist/src/parity/actoviqBridgeSdk.js

@@ -0,0 +1,1267 @@
+import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { constants as fsConstants } from 'node:fs';
+import { access } from 'node:fs/promises';
+import path from 'node:path';
+import readline from 'node:readline';
+import { fileURLToPath } from 'node:url';
+import { createActoviqBuddyApi } from '../buddy/actoviqBuddy.js';
+import { getLoadedJsonConfig } from '../config/loadJsonConfigFile.js';
+import { ActoviqBridgeProcessError, RunAbortedError } from '../errors.js';
+import { createActoviqMemoryApi } from '../memory/actoviqMemory.js';
+import { AsyncQueue } from '../runtime/asyncQueue.js';
+import { asError, isRecord } from '../runtime/helpers.js';
+import { getActoviqBridgeCompactBoundaries, getActoviqBridgeLatestCompactBoundary, getActoviqBridgeSessionInfo, getActoviqBridgeSessionMessages, listActoviqBridgeSessions, } from './actoviqTranscripts.js';
+const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
+const IS_WINDOWS = process.platform === 'win32';
+function isAbortErrorLike(error) {
+    return error instanceof RunAbortedError || (error instanceof Error && error.name === 'AbortError');
+}
+async function pathExists(filePath) {
+    try {
+        await access(filePath, fsConstants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function isExecutable(filePath) {
+    try {
+        await access(filePath, IS_WINDOWS ? fsConstants.F_OK : fsConstants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function splitPathEnv(pathValue) {
+    if (!pathValue) {
+        return [];
+    }
+    return pathValue.split(path.delimiter).filter(Boolean);
+}
+async function findExecutableOnPath(name) {
+    const pathDirectories = splitPathEnv(process.env.PATH);
+    const extensions = IS_WINDOWS
+        ? (process.env.PATHEXT ?? '.COM;.EXE;.BAT;.CMD')
+            .split(';')
+            .filter(Boolean)
+        : [''];
+    for (const directory of pathDirectories) {
+        const directCandidate = path.join(directory, name);
+        if (!IS_WINDOWS && (await isExecutable(directCandidate))) {
+            return directCandidate;
+        }
+        for (const extension of extensions) {
+            const candidate = directCandidate.endsWith(extension.toLowerCase())
+                ? directCandidate
+                : `${directCandidate}${extension.toLowerCase()}`;
+            if (await isExecutable(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    return undefined;
+}
+async function findFirstExistingPath(candidates) {
+    for (const candidate of candidates) {
+        if (!candidate) {
+            continue;
+        }
+        if (await pathExists(candidate)) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+async function resolveBunExecutable(explicitPath) {
+    if (explicitPath) {
+        if (!(await isExecutable(explicitPath))) {
+            throw new ActoviqBridgeProcessError(`The configured executable was not found or is not executable: ${explicitPath}`);
+        }
+        return explicitPath;
+    }
+    const localCandidate = await findFirstExistingPath([
+        ...(IS_WINDOWS
+            ? [
+                path.resolve(MODULE_DIR, '..', '..', 'node_modules', 'bun', 'bin', 'bun.exe'),
+                path.resolve(MODULE_DIR, '..', '..', '..', 'node_modules', 'bun', 'bin', 'bun.exe'),
+                path.resolve(process.cwd(), 'node_modules', 'bun', 'bin', 'bun.exe'),
+            ]
+            : []),
+        path.resolve(MODULE_DIR, '..', '..', 'node_modules', '.bin', `bun${IS_WINDOWS ? '.cmd' : ''}`),
+        path.resolve(MODULE_DIR, '..', '..', '..', 'node_modules', '.bin', `bun${IS_WINDOWS ? '.cmd' : ''}`),
+        path.resolve(process.cwd(), 'node_modules', '.bin', `bun${IS_WINDOWS ? '.cmd' : ''}`),
+    ]);
+    if (localCandidate) {
+        return localCandidate;
+    }
+    const pathCandidate = await findExecutableOnPath('bun');
+    if (pathCandidate) {
+        return pathCandidate;
+    }
+    throw new ActoviqBridgeProcessError('Bun is required for the Actoviq Runtime bridge, but no bun executable was found. Install Bun or pass { executable }.');
+}
+async function resolveActoviqRuntimeCliPath(explicitPath) {
+    if (explicitPath) {
+        if (!(await pathExists(explicitPath))) {
+            throw new ActoviqBridgeProcessError(`Actoviq Runtime CLI entry was not found: ${explicitPath}`);
+        }
+        return explicitPath;
+    }
+    const resolved = await findFirstExistingPath([
+        path.resolve(MODULE_DIR, '..', '..', 'vendor', 'actoviq-runtime', 'cli.js'),
+        path.resolve(MODULE_DIR, '..', '..', '..', 'vendor', 'actoviq-runtime', 'cli.js'),
+        path.resolve(process.cwd(), 'vendor', 'actoviq-runtime', 'cli.js'),
+    ]);
+    if (!resolved) {
+        throw new ActoviqBridgeProcessError('Actoviq Runtime CLI entry was not found. Run npm run sync:actoviq-runtime or pass { cliPath } explicitly.');
+    }
+    return resolved;
+}
+function stringifyCliValue(value) {
+    return typeof value === 'string' ? value : JSON.stringify(value);
+}
+function normalizeToolsArgument(tools) {
+    if (tools == null) {
+        return undefined;
+    }
+    if (tools === 'default') {
+        return 'default';
+    }
+    if (tools === 'none') {
+        return '';
+    }
+    return tools.join(',');
+}
+function appendRepeatableArgs(args, flag, values) {
+    if (!values?.length) {
+        return;
+    }
+    args.push(flag, ...values);
+}
+function appendOptionalArg(args, flag, value) {
+    if (value == null || value === '') {
+        return;
+    }
+    args.push(flag, String(value));
+}
+function getStringValue(event, key) {
+    const value = event?.[key];
+    return typeof value === 'string' ? value : undefined;
+}
+function getNumberValue(event, key) {
+    const value = event?.[key];
+    return typeof value === 'number' ? value : undefined;
+}
+function getBooleanValue(event, key) {
+    const value = event?.[key];
+    return typeof value === 'boolean' ? value : undefined;
+}
+function extractAssistantText(event) {
+    const message = event.message;
+    if (!isRecord(message)) {
+        return '';
+    }
+    const content = message.content;
+    if (!Array.isArray(content)) {
+        return '';
+    }
+    return content
+        .map(block => {
+        if (!isRecord(block)) {
+            return '';
+        }
+        return block.type === 'text' && typeof block.text === 'string' ? block.text : '';
+    })
+        .join('');
+}
+function deriveResultText(resultEvent, assistantMessages) {
+    const rawResult = resultEvent?.result;
+    if (typeof rawResult === 'string') {
+        return rawResult;
+    }
+    for (let index = assistantMessages.length - 1; index >= 0; index -= 1) {
+        const text = extractAssistantText(assistantMessages[index]);
+        if (text) {
+            return text;
+        }
+    }
+    return '';
+}
+function getStringArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter((entry) => typeof entry === 'string');
+}
+function getObjectArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter((entry) => isRecord(entry));
+}
+function parseMarkdownTable(markdown, heading) {
+    const headingIndex = markdown.indexOf(`### ${heading}`);
+    if (headingIndex === -1) {
+        return [];
+    }
+    const afterHeading = markdown.slice(headingIndex).split(/\r?\n/).slice(1);
+    const tableLines = [];
+    for (const line of afterHeading) {
+        if (line.startsWith('### ')) {
+            break;
+        }
+        if (line.trim().startsWith('|')) {
+            tableLines.push(line.trim());
+            continue;
+        }
+        if (tableLines.length > 0 && !line.trim()) {
+            break;
+        }
+    }
+    if (tableLines.length < 3) {
+        return [];
+    }
+    const headers = tableLines[0]
+        .split('|')
+        .map(cell => cell.trim())
+        .filter(Boolean);
+    const rows = tableLines.slice(2);
+    return rows.map(row => {
+        const cells = row
+            .split('|')
+            .map(cell => cell.trim())
+            .filter(Boolean);
+        return Object.fromEntries(headers.map((header, index) => [header, cells[index] ?? '']));
+    });
+}
+function parseActoviqContextUsageResult(result) {
+    const markdown = result.text;
+    const modelMatch = markdown.match(/\*\*Model:\*\*\s+([^\r\n]+)/u);
+    const tokensMatch = markdown.match(/\*\*Tokens:\*\*\s+(.+?)\s+\/\s+(.+?)\s+\(([\d.]+)%\)/u);
+    return {
+        markdown,
+        model: modelMatch?.[1]?.trim(),
+        tokensUsed: tokensMatch?.[1]?.trim(),
+        tokenLimit: tokensMatch?.[2]?.trim(),
+        percentage: tokensMatch?.[3] ? Number(tokensMatch[3]) : undefined,
+        categories: parseMarkdownTable(markdown, 'Estimated usage by category').map(row => ({
+            name: row.Category ?? '',
+            tokens: row.Tokens ?? '',
+            percentage: row.Percentage ?? '',
+        })),
+        skills: parseMarkdownTable(markdown, 'Skills').map(row => ({
+            name: row.Skill ?? '',
+            source: row.Source || undefined,
+            tokens: row.Tokens ?? '',
+        })),
+        agents: parseMarkdownTable(markdown, 'Custom Agents').map(row => ({
+            agentType: row['Agent Type'] ?? '',
+            source: row.Source || undefined,
+            tokens: row.Tokens ?? '',
+        })),
+        mcpTools: parseMarkdownTable(markdown, 'MCP Tools').map(row => ({
+            tool: row.Tool ?? '',
+            server: row.Server ?? '',
+            tokens: row.Tokens ?? '',
+        })),
+        rawResult: result,
+    };
+}
+function runtimeInfoFromInitEvent(initEvent) {
+    return {
+        sessionId: getStringValue(initEvent, 'session_id') ?? '',
+        cwd: getStringValue(initEvent, 'cwd'),
+        model: getStringValue(initEvent, 'model'),
+        permissionMode: getStringValue(initEvent, 'permissionMode'),
+        tools: getStringArray(initEvent.tools),
+        mcpServers: getObjectArray(initEvent.mcp_servers).map(server => ({
+            name: typeof server.name === 'string' ? server.name : '',
+            status: typeof server.status === 'string' ? server.status : undefined,
+        })),
+        slashCommands: getStringArray(initEvent.slash_commands),
+        agents: getStringArray(initEvent.agents),
+        skills: getStringArray(initEvent.skills),
+        plugins: getObjectArray(initEvent.plugins).map(plugin => ({
+            name: typeof plugin.name === 'string' ? plugin.name : '',
+            path: typeof plugin.path === 'string' ? plugin.path : undefined,
+            source: typeof plugin.source === 'string' ? plugin.source : undefined,
+        })),
+        rawInitEvent: structuredClone(initEvent),
+    };
+}
+function parseActoviqAgentSummaryOutput(stdout) {
+    const agents = [];
+    let currentGroup = 'Unknown';
+    for (const line of stdout.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            continue;
+        }
+        if (/^\d+\s+active\s+agents$/u.test(trimmed)) {
+            continue;
+        }
+        if (trimmed.endsWith(':')) {
+            currentGroup = trimmed.slice(0, -1);
+            continue;
+        }
+        let active = true;
+        let shadowedBy;
+        let descriptor = trimmed;
+        const shadowedMatch = trimmed.match(/^\(shadowed by ([^)]+)\)\s+(.+)$/u);
+        if (shadowedMatch) {
+            active = false;
+            shadowedBy = shadowedMatch[1]?.trim();
+            descriptor = shadowedMatch[2] ?? trimmed;
+        }
+        const parts = descriptor.split(/\s+·\s+/u).map(part => part.trim()).filter(Boolean);
+        const name = parts.shift();
+        if (!name) {
+            continue;
+        }
+        let model;
+        let memory;
+        for (const part of parts) {
+            if (part.endsWith(' memory')) {
+                memory = part.replace(/ memory$/u, '');
+            }
+            else if (!model) {
+                model = part;
+            }
+        }
+        agents.push({
+            name,
+            sourceGroup: currentGroup,
+            active,
+            rawLine: trimmed,
+            model,
+            memory,
+            shadowedBy,
+        });
+    }
+    return agents;
+}
+function formatSlashCommand(commandName, args = '') {
+    const normalizedName = commandName.trim().replace(/^\/+/u, '');
+    const normalizedArgs = args.trim();
+    return normalizedArgs ? `/${normalizedName} ${normalizedArgs}` : `/${normalizedName}`;
+}
+function buildRuntimeCatalog(params) {
+    const { runtime, agents, context } = params;
+    const contextSkillMap = new Map(context?.skills.map(skill => [skill.name, skill]) ?? []);
+    const contextAgentMap = new Map(context?.agents.map(agent => [agent.agentType, agent]) ?? []);
+    const contextMcpToolMap = new Map(context?.mcpTools.map(tool => [tool.tool, tool]) ?? []);
+    const skillNames = new Set(runtime.skills);
+    const tools = runtime.tools.map(name => {
+        const contextTool = contextMcpToolMap.get(name);
+        return {
+            name,
+            kind: contextTool ? 'mcp' : 'builtin',
+            server: contextTool?.server,
+            tokens: contextTool?.tokens,
+        };
+    });
+    const skills = runtime.skills.map(name => {
+        const contextSkill = contextSkillMap.get(name);
+        return {
+            name,
+            slashCommand: `/${name}`,
+            source: contextSkill?.source,
+            tokens: contextSkill?.tokens,
+        };
+    });
+    const slashCommands = runtime.slashCommands.map(name => ({
+        name,
+        kind: skillNames.has(name) ? 'skill' : 'builtin',
+        skillName: skillNames.has(name) ? name : undefined,
+    }));
+    const enrichedAgents = agents.map(agent => {
+        const contextAgent = contextAgentMap.get(agent.name);
+        return {
+            ...agent,
+            contextSource: contextAgent?.source,
+            tokens: contextAgent?.tokens,
+        };
+    });
+    return {
+        runtime,
+        agents: enrichedAgents,
+        tools,
+        skills,
+        slashCommands,
+        context,
+    };
+}
+function buildCliArgs(prompt, options) {
+    const args = [
+        '-p',
+        prompt,
+        '--output-format',
+        'stream-json',
+        '--verbose',
+    ];
+    if (options.includePartialMessages ?? true) {
+        args.push('--include-partial-messages');
+    }
+    if (options.includeHookEvents) {
+        args.push('--include-hook-events');
+    }
+    if (options.bare) {
+        args.push('--bare');
+    }
+    if (options.disableSlashCommands) {
+        args.push('--disable-slash-commands');
+    }
+    if (options.strictMcpConfig) {
+        args.push('--strict-mcp-config');
+    }
+    if (options.continueMostRecent) {
+        args.push('--continue');
+    }
+    if (options.forkSession) {
+        args.push('--fork-session');
+    }
+    const shouldSkipPermissions = options.dangerouslySkipPermissions ??
+        (options.permissionMode == null || options.permissionMode === 'bypassPermissions');
+    if (shouldSkipPermissions) {
+        args.push('--dangerously-skip-permissions');
+    }
+    appendOptionalArg(args, '--permission-mode', options.permissionMode);
+    appendOptionalArg(args, '--model', options.model);
+    appendOptionalArg(args, '--fallback-model', options.fallbackModel);
+    appendOptionalArg(args, '--effort', options.effort);
+    appendOptionalArg(args, '--system-prompt', options.systemPrompt);
+    appendOptionalArg(args, '--append-system-prompt', options.appendSystemPrompt);
+    appendOptionalArg(args, '--max-turns', options.maxTurns);
+    appendOptionalArg(args, '--max-budget-usd', options.maxBudgetUsd);
+    appendOptionalArg(args, '--agent', options.agent);
+    appendOptionalArg(args, '-n', options.name);
+    appendOptionalArg(args, '--setting-sources', options.settingSources);
+    if (options.jsonSchema != null) {
+        args.push('--json-schema', stringifyCliValue(options.jsonSchema));
+    }
+    if (options.settings != null) {
+        args.push('--settings', stringifyCliValue(options.settings));
+    }
+    if (options.agents != null) {
+        args.push('--agents', JSON.stringify(options.agents));
+    }
+    const toolsArg = normalizeToolsArgument(options.tools);
+    if (toolsArg != null) {
+        args.push('--tools', toolsArg);
+    }
+    if (options.allowedTools?.length) {
+        args.push('--allowedTools', options.allowedTools.join(','));
+    }
+    if (options.disallowedTools?.length) {
+        args.push('--disallowedTools', options.disallowedTools.join(','));
+    }
+    appendRepeatableArgs(args, '--add-dir', options.addDirs);
+    appendRepeatableArgs(args, '--plugin-dir', options.pluginDirs);
+    appendRepeatableArgs(args, '--file', options.files);
+    if (options.mcpConfigs?.length) {
+        args.push('--mcp-config', ...options.mcpConfigs.map(config => stringifyCliValue(config)));
+    }
+    if (typeof options.resume === 'string') {
+        args.push('--resume', options.resume);
+    }
+    else if (options.resume === true) {
+        args.push('--resume');
+    }
+    else if (options.sessionId) {
+        args.push('--session-id', options.sessionId);
+    }
+    if (options.cliArgs?.length) {
+        args.push(...options.cliArgs);
+    }
+    return args;
+}
+function buildChildEnvironment(envOverrides) {
+    const loadedConfig = getLoadedJsonConfig();
+    const mergedEnv = {
+        ...Object.fromEntries(Object.entries(process.env).filter((entry) => typeof entry[1] === 'string')),
+        ...(loadedConfig?.env ?? {}),
+        ...(envOverrides ?? {}),
+    };
+    return mergedEnv;
+}
+async function prefersSystemRipgrep(envOverrides) {
+    const explicit = envOverrides?.USE_BUILTIN_RIPGREP ?? process.env.USE_BUILTIN_RIPGREP;
+    if (explicit != null) {
+        return false;
+    }
+    return Boolean(await findExecutableOnPath('rg'));
+}
+async function parseStdoutEvents(child, onEvent) {
+    if (!child.stdout) {
+        return;
+    }
+    const stream = readline.createInterface({ input: child.stdout, crlfDelay: Infinity });
+    for await (const line of stream) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            continue;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch (error) {
+            throw new ActoviqBridgeProcessError(`Failed to parse Actoviq Runtime stream line: ${trimmed}`, {
+                cause: error,
+            });
+        }
+        if (!isRecord(parsed) || typeof parsed.type !== 'string') {
+            throw new ActoviqBridgeProcessError('Actoviq Runtime emitted a malformed stream event.');
+        }
+        onEvent(parsed);
+    }
+}
+async function readStderr(child) {
+    if (!child.stderr) {
+        return '';
+    }
+    let stderr = '';
+    for await (const chunk of child.stderr) {
+        stderr += chunk.toString();
+    }
+    return stderr;
+}
+async function readStdout(child) {
+    if (!child.stdout) {
+        return '';
+    }
+    let stdout = '';
+    for await (const chunk of child.stdout) {
+        stdout += chunk.toString();
+    }
+    return stdout;
+}
+export class ActoviqBridgeRunStream {
+    queue = new AsyncQueue();
+    result;
+    constructor(executor) {
+        this.result = (async () => {
+            try {
+                return await executor({
+                    emit: event => this.queue.push(event),
+                    fail: error => this.queue.fail(error),
+                    close: () => this.queue.close(),
+                });
+            }
+            catch (error) {
+                this.queue.fail(error);
+                throw error;
+            }
+            finally {
+                this.queue.close();
+            }
+        })();
+    }
+    [Symbol.asyncIterator]() {
+        return this.queue[Symbol.asyncIterator]();
+    }
+}
+export class ActoviqBridgeSession {
+    client;
+    id;
+    title;
+    defaults;
+    started;
+    constructor(client, id, title, defaults, started = false) {
+        this.client = client;
+        this.id = id;
+        this.title = title;
+        this.defaults = defaults;
+        this.started = started;
+    }
+    async send(prompt, options = {}) {
+        const result = await this.client.run(prompt, this.buildRunOptions(options));
+        this.started = true;
+        return result;
+    }
+    stream(prompt, options = {}) {
+        const runStream = this.client.stream(prompt, this.buildRunOptions(options));
+        void runStream.result.then(() => {
+            this.started = true;
+        }, () => undefined);
+        return runStream;
+    }
+    runSlashCommand(commandName, args = '', options = {}) {
+        return this.send(formatSlashCommand(commandName, args), options);
+    }
+    runSkill(skill, args = '', options = {}) {
+        return this.runSlashCommand(skill, args, options);
+    }
+    streamSlashCommand(commandName, args = '', options = {}) {
+        return this.stream(formatSlashCommand(commandName, args), options);
+    }
+    streamSkill(skill, args = '', options = {}) {
+        return this.streamSlashCommand(skill, args, options);
+    }
+    compact(args = '', options = {}) {
+        return this.runSlashCommand('compact', args, options);
+    }
+    info(options) {
+        return getActoviqBridgeSessionInfo(this.id, options);
+    }
+    messages(options) {
+        return getActoviqBridgeSessionMessages(this.id, options);
+    }
+    compactBoundaries(options) {
+        return getActoviqBridgeCompactBoundaries(this.id, options);
+    }
+    latestCompactBoundary(options) {
+        return getActoviqBridgeLatestCompactBoundary(this.id, options);
+    }
+    compactState(options = {}) {
+        return this.client.memory.compactState({
+            ...options,
+            sessionId: this.id,
+        });
+    }
+    fork(prompt, options = {}) {
+        return this.client.run(prompt, {
+            ...this.defaults,
+            ...options,
+            resume: this.id,
+            forkSession: true,
+        });
+    }
+    forkStream(prompt, options = {}) {
+        return this.client.stream(prompt, {
+            ...this.defaults,
+            ...options,
+            resume: this.id,
+            forkSession: true,
+        });
+    }
+    buildRunOptions(options) {
+        const merged = {
+            ...this.defaults,
+            ...options,
+            name: options.name ?? this.title,
+        };
+        if (this.started) {
+            merged.resume = this.id;
+        }
+        else {
+            merged.sessionId = this.id;
+        }
+        return merged;
+    }
+}
+export class ActoviqBridgeAgentHandle {
+    client;
+    agent;
+    defaults;
+    constructor(client, agent, defaults = {}) {
+        this.client = client;
+        this.agent = agent;
+        this.defaults = defaults;
+    }
+    run(prompt, options = {}) {
+        return this.client.run(prompt, {
+            ...this.defaults,
+            ...options,
+            agent: this.agent,
+        });
+    }
+    stream(prompt, options = {}) {
+        return this.client.stream(prompt, {
+            ...this.defaults,
+            ...options,
+            agent: this.agent,
+        });
+    }
+    createSession(options = {}) {
+        return this.client.createSession({
+            ...this.defaults,
+            ...options,
+            agent: this.agent,
+        });
+    }
+}
+export class ActoviqBridgeSkillHandle {
+    client;
+    skill;
+    defaults;
+    constructor(client, skill, defaults = {}) {
+        this.client = client;
+        this.skill = skill;
+        this.defaults = defaults;
+    }
+    run(args = '', options = {}) {
+        return this.client.runSlashCommand(this.skill, args, {
+            ...this.defaults,
+            ...options,
+        });
+    }
+    stream(args = '', options = {}) {
+        return this.client.streamSlashCommand(this.skill, args, {
+            ...this.defaults,
+            ...options,
+        });
+    }
+    async runInSession(session, args = '', options = {}) {
+        return session.runSlashCommand(this.skill, args, options);
+    }
+    streamInSession(session, args = '', options = {}) {
+        return session.streamSlashCommand(this.skill, args, options);
+    }
+    metadata(options) {
+        return this.client.getSkillMetadata(this.skill, options);
+    }
+}
+export class ActoviqBridgeAgentsApi {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    list(options) {
+        return this.client.listAgents(options);
+    }
+    use(agent, defaults = {}) {
+        return new ActoviqBridgeAgentHandle(this.client, agent, defaults);
+    }
+    run(agent, prompt, options = {}) {
+        return this.client.run(prompt, {
+            ...options,
+            agent,
+        });
+    }
+    stream(agent, prompt, options = {}) {
+        return this.client.stream(prompt, {
+            ...options,
+            agent,
+        });
+    }
+    createSession(agent, options = {}) {
+        return this.client.createSession({
+            ...options,
+            agent,
+        });
+    }
+}
+export class ActoviqBridgeSkillsApi {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    list(options) {
+        return this.client.listSkills(options);
+    }
+    use(skill, defaults = {}) {
+        return new ActoviqBridgeSkillHandle(this.client, skill, defaults);
+    }
+    run(skill, args = '', options = {}) {
+        return this.client.runSlashCommand(skill, args, options);
+    }
+    stream(skill, args = '', options = {}) {
+        return this.client.streamSlashCommand(skill, args, options);
+    }
+    listMetadata(options) {
+        return this.client.listSkillMetadata(options);
+    }
+    getMetadata(skill, options) {
+        return this.client.getSkillMetadata(skill, options);
+    }
+}
+export class ActoviqBridgeToolsApi {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    list(options) {
+        return this.client.listTools(options);
+    }
+    listMetadata(options) {
+        return this.client.listToolMetadata(options);
+    }
+    getMetadata(toolName, options) {
+        return this.client.getToolMetadata(toolName, options);
+    }
+}
+export class ActoviqBridgeSlashCommandsApi {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    list(options) {
+        return this.client.listSlashCommands(options);
+    }
+    listMetadata(options) {
+        return this.client.listSlashCommandMetadata(options);
+    }
+    getMetadata(commandName, options) {
+        return this.client.getSlashCommandMetadata(commandName, options);
+    }
+    run(commandName, args = '', options = {}) {
+        return this.client.runSlashCommand(commandName, args, options);
+    }
+    stream(commandName, args = '', options = {}) {
+        return this.client.streamSlashCommand(commandName, args, options);
+    }
+}
+export class ActoviqBridgeContextApi {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    usage(options) {
+        return this.client.getContextUsage(options);
+    }
+    compact(args = '', options = {}) {
+        return this.client.runSlashCommand('compact', args, options);
+    }
+    streamCompact(args = '', options = {}) {
+        return this.client.streamSlashCommand('compact', args, options);
+    }
+    compactBoundaries(sessionId, options) {
+        return getActoviqBridgeCompactBoundaries(sessionId, options);
+    }
+    latestCompactBoundary(sessionId, options) {
+        return getActoviqBridgeLatestCompactBoundary(sessionId, options);
+    }
+    compactState(sessionId, options = {}) {
+        return this.client.memory.compactState({
+            ...options,
+            sessionId,
+        });
+    }
+}
+export class ActoviqBridgeSessionsApi {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    list(options) {
+        return listActoviqBridgeSessions(options);
+    }
+    getInfo(sessionId, options) {
+        return getActoviqBridgeSessionInfo(sessionId, options);
+    }
+    getMessages(sessionId, options) {
+        return getActoviqBridgeSessionMessages(sessionId, options);
+    }
+    getCompactBoundaries(sessionId, options) {
+        return getActoviqBridgeCompactBoundaries(sessionId, options);
+    }
+    getLatestCompactBoundary(sessionId, options) {
+        return getActoviqBridgeLatestCompactBoundary(sessionId, options);
+    }
+    getCompactState(sessionId, options = {}) {
+        return this.client.memory.compactState({
+            ...options,
+            sessionId,
+        });
+    }
+    async resume(sessionId, options = {}) {
+        return this.client.resumeSession(sessionId, options);
+    }
+    continueMostRecent(prompt, options = {}) {
+        return this.client.continueMostRecent(prompt, options);
+    }
+    streamContinueMostRecent(prompt, options = {}) {
+        return this.client.streamContinueMostRecent(prompt, options);
+    }
+    fork(sessionId, prompt, options = {}) {
+        return this.client.forkSession(sessionId, prompt, options);
+    }
+    streamFork(sessionId, prompt, options = {}) {
+        return this.client.streamForkSession(sessionId, prompt, options);
+    }
+    getRuntimeInfo(options) {
+        return this.client.getRuntimeInfo(options);
+    }
+    listAgents(options) {
+        return this.client.listAgents(options);
+    }
+    listSkills(options) {
+        return this.client.listSkills(options);
+    }
+    listSlashCommands(options) {
+        return this.client.listSlashCommands(options);
+    }
+    listTools(options) {
+        return this.client.listTools(options);
+    }
+    getRuntimeCatalog(options) {
+        return this.client.getRuntimeCatalog(options);
+    }
+    listSkillMetadata(options) {
+        return this.client.listSkillMetadata(options);
+    }
+    listSlashCommandMetadata(options) {
+        return this.client.listSlashCommandMetadata(options);
+    }
+    listToolMetadata(options) {
+        return this.client.listToolMetadata(options);
+    }
+    getContextUsage(options) {
+        return this.client.getContextUsage(options);
+    }
+}
+export class ActoviqBridgeSdkClient {
+    executable;
+    cliPath;
+    defaults;
+    sessions;
+    agents;
+    skills;
+    tools;
+    slashCommands;
+    context;
+    buddy;
+    memory;
+    constructor(executable, cliPath, defaults) {
+        this.executable = executable;
+        this.cliPath = cliPath;
+        this.defaults = defaults;
+        this.sessions = new ActoviqBridgeSessionsApi(this);
+        this.agents = new ActoviqBridgeAgentsApi(this);
+        this.skills = new ActoviqBridgeSkillsApi(this);
+        this.tools = new ActoviqBridgeToolsApi(this);
+        this.slashCommands = new ActoviqBridgeSlashCommandsApi(this);
+        this.context = new ActoviqBridgeContextApi(this);
+        this.buddy = createActoviqBuddyApi({
+            homeDir: this.defaults.homeDir,
+        });
+        this.memory = createActoviqMemoryApi({
+            homeDir: this.defaults.homeDir,
+            projectPath: this.defaults.workDir ?? process.cwd(),
+        });
+    }
+    static async create(options = {}) {
+        const executable = await resolveBunExecutable(options.executable);
+        const cliPath = await resolveActoviqRuntimeCliPath(options.cliPath);
+        return new ActoviqBridgeSdkClient(executable, cliPath, {
+            ...options,
+            executable: undefined,
+            cliPath: undefined,
+        });
+    }
+    async run(prompt, options = {}) {
+        const stream = this.stream(prompt, options);
+        return stream.result;
+    }
+    runSlashCommand(commandName, args = '', options = {}) {
+        return this.run(formatSlashCommand(commandName, args), options);
+    }
+    runWithAgent(agent, prompt, options = {}) {
+        return this.run(prompt, {
+            ...options,
+            agent,
+        });
+    }
+    runSkill(skill, args = '', options = {}) {
+        return this.runSlashCommand(skill, args, options);
+    }
+    continueMostRecent(prompt, options = {}) {
+        return this.run(prompt, {
+            ...options,
+            continueMostRecent: true,
+        });
+    }
+    streamContinueMostRecent(prompt, options = {}) {
+        return this.stream(prompt, {
+            ...options,
+            continueMostRecent: true,
+        });
+    }
+    forkSession(sessionId, prompt, options = {}) {
+        return this.run(prompt, {
+            ...options,
+            resume: sessionId,
+            forkSession: true,
+        });
+    }
+    streamForkSession(sessionId, prompt, options = {}) {
+        return this.stream(prompt, {
+            ...options,
+            resume: sessionId,
+            forkSession: true,
+        });
+    }
+    stream(prompt, options = {}) {
+        const mergedOptions = this.mergeOptions(options);
+        return new ActoviqBridgeRunStream(async (controller) => {
+            return this.execute(prompt, mergedOptions, controller);
+        });
+    }
+    streamSlashCommand(commandName, args = '', options = {}) {
+        return this.stream(formatSlashCommand(commandName, args), options);
+    }
+    streamWithAgent(agent, prompt, options = {}) {
+        return this.stream(prompt, {
+            ...options,
+            agent,
+        });
+    }
+    streamSkill(skill, args = '', options = {}) {
+        return this.streamSlashCommand(skill, args, options);
+    }
+    async createSession(options = {}) {
+        const sessionId = options.sessionId ?? randomUUID();
+        return new ActoviqBridgeSession(this, sessionId, options.title, this.mergeOptions(options), false);
+    }
+    createAgentSession(agent, options = {}) {
+        return this.createSession({
+            ...options,
+            agent,
+        });
+    }
+    useAgent(agent, defaults = {}) {
+        return this.agents.use(agent, defaults);
+    }
+    useSkill(skill, defaults = {}) {
+        return this.skills.use(skill, defaults);
+    }
+    async resumeSession(sessionId, options = {}) {
+        return new ActoviqBridgeSession(this, sessionId, options.title, this.mergeOptions(options), true);
+    }
+    async close() {
+        return Promise.resolve();
+    }
+    async getRuntimeInfo(options = {}) {
+        const result = await this.run('/cost', {
+            ...options,
+            includePartialMessages: false,
+            maxTurns: options.maxTurns ?? 2,
+        });
+        if (!result.initEvent) {
+            throw new ActoviqBridgeProcessError('Actoviq Runtime did not emit an init event for /cost.');
+        }
+        return runtimeInfoFromInitEvent(result.initEvent);
+    }
+    async listSkills(options = {}) {
+        const info = await this.getRuntimeInfo(options);
+        return [...info.skills];
+    }
+    async listTools(options = {}) {
+        const info = await this.getRuntimeInfo(options);
+        return [...info.tools];
+    }
+    async listSlashCommands(options = {}) {
+        const info = await this.getRuntimeInfo(options);
+        return [...info.slashCommands];
+    }
+    async listAgents(options = {}) {
+        const raw = await this.runRawCliCommand(['agents'], options);
+        return parseActoviqAgentSummaryOutput(raw.stdout);
+    }
+    async getContextUsage(options = {}) {
+        const result = await this.run('/context', {
+            ...options,
+            includePartialMessages: false,
+            maxTurns: options.maxTurns ?? 2,
+        });
+        return parseActoviqContextUsageResult(result);
+    }
+    async getRuntimeCatalog(options = {}) {
+        const runtimeOptions = {
+            ...options,
+        };
+        delete runtimeOptions.includeContext;
+        const [runtime, agents, context] = await Promise.all([
+            this.getRuntimeInfo(runtimeOptions),
+            this.listAgents(runtimeOptions),
+            options.includeContext === false
+                ? Promise.resolve(undefined)
+                : this.getContextUsage(runtimeOptions).catch(() => undefined),
+        ]);
+        return buildRuntimeCatalog({
+            runtime,
+            agents,
+            context,
+        });
+    }
+    async listSkillMetadata(options = {}) {
+        const catalog = await this.getRuntimeCatalog(options);
+        return catalog.skills;
+    }
+    async getSkillMetadata(skillName, options = {}) {
+        const catalog = await this.getRuntimeCatalog(options);
+        return catalog.skills.find(skill => skill.name === skillName);
+    }
+    async listToolMetadata(options = {}) {
+        const catalog = await this.getRuntimeCatalog(options);
+        return catalog.tools;
+    }
+    async getToolMetadata(toolName, options = {}) {
+        const catalog = await this.getRuntimeCatalog(options);
+        return catalog.tools.find(tool => tool.name === toolName);
+    }
+    async listSlashCommandMetadata(options = {}) {
+        const catalog = await this.getRuntimeCatalog(options);
+        return catalog.slashCommands;
+    }
+    async getSlashCommandMetadata(commandName, options = {}) {
+        const normalized = commandName.trim().replace(/^\/+/u, '');
+        const catalog = await this.getRuntimeCatalog(options);
+        return catalog.slashCommands.find(command => command.name === normalized);
+    }
+    compactContext(args = '', options = {}) {
+        return this.runSlashCommand('compact', args, options);
+    }
+    mergeOptions(options) {
+        return {
+            ...this.defaults,
+            ...options,
+            executable: this.executable,
+            cliPath: this.cliPath,
+            workDir: options.workDir ?? this.defaults.workDir ?? process.cwd(),
+        };
+    }
+    async runRawCliCommand(rawArgs, options = {}) {
+        if (options.signal?.aborted) {
+            throw new RunAbortedError('The Actoviq Runtime command was aborted before it started.');
+        }
+        const merged = this.mergeOptions(options);
+        const childEnv = buildChildEnvironment(merged.env);
+        if (await prefersSystemRipgrep(merged.env)) {
+            childEnv.USE_BUILTIN_RIPGREP = '0';
+        }
+        const child = spawn(merged.executable ?? this.executable, [merged.cliPath ?? this.cliPath, ...rawArgs], {
+            cwd: merged.workDir ?? this.defaults.workDir ?? process.cwd(),
+            env: childEnv,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            windowsHide: true,
+            shell: IS_WINDOWS &&
+                /\.(?:cmd|bat)$/i.test(merged.executable ?? this.executable),
+        });
+        let aborted = false;
+        const abort = () => {
+            aborted = true;
+            child.kill('SIGTERM');
+        };
+        options.signal?.addEventListener('abort', abort, { once: true });
+        const stdoutPromise = readStdout(child);
+        const stderrPromise = readStderr(child);
+        const exitCodePromise = new Promise((resolve, reject) => {
+            child.once('error', reject);
+            child.once('close', code => resolve(code));
+        });
+        try {
+            const [stdout, stderr, exitCode] = await Promise.all([
+                stdoutPromise,
+                stderrPromise,
+                exitCodePromise,
+            ]);
+            if (aborted) {
+                throw new RunAbortedError('The Actoviq Runtime command was aborted.');
+            }
+            if (exitCode !== 0) {
+                throw new ActoviqBridgeProcessError(stderr.trim()
+                    ? `Actoviq Runtime command failed: ${stderr.trim()}`
+                    : `Actoviq Runtime command failed with exit code ${exitCode}.`, { stderr, exitCode });
+            }
+            return { stdout, stderr, exitCode };
+        }
+        catch (error) {
+            const normalized = asError(error);
+            if (aborted || isAbortErrorLike(normalized)) {
+                throw new RunAbortedError('The Actoviq Runtime command was aborted.', { cause: error });
+            }
+            throw new ActoviqBridgeProcessError(normalized.message, { cause: error });
+        }
+        finally {
+            options.signal?.removeEventListener('abort', abort);
+        }
+    }
+    async execute(prompt, options, controller) {
+        if (options.signal?.aborted) {
+            throw new RunAbortedError('The Actoviq Runtime run was aborted before it started.');
+        }
+        const childEnv = buildChildEnvironment(options.env);
+        if (await prefersSystemRipgrep(options.env)) {
+            childEnv.USE_BUILTIN_RIPGREP = '0';
+        }
+        const args = [options.cliPath ?? this.cliPath, ...buildCliArgs(prompt, options)];
+        const child = spawn(options.executable ?? this.executable, args, {
+            cwd: options.workDir ?? this.defaults.workDir ?? process.cwd(),
+            env: childEnv,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            windowsHide: true,
+            shell: IS_WINDOWS &&
+                /\.(?:cmd|bat)$/i.test(options.executable ?? this.executable),
+        });
+        const events = [];
+        const assistantMessages = [];
+        let initEvent;
+        let resultEvent;
+        let aborted = false;
+        const abort = () => {
+            aborted = true;
+            child.kill('SIGTERM');
+        };
+        options.signal?.addEventListener('abort', abort, { once: true });
+        const stdoutPromise = parseStdoutEvents(child, event => {
+            events.push(structuredClone(event));
+            if (event.type === 'system' && event.subtype === 'init') {
+                initEvent = structuredClone(event);
+            }
+            if (event.type === 'assistant') {
+                assistantMessages.push(structuredClone(event));
+            }
+            if (event.type === 'result') {
+                resultEvent = structuredClone(event);
+            }
+            controller.emit(event);
+        });
+        const stderrPromise = readStderr(child);
+        const exitCodePromise = new Promise((resolve, reject) => {
+            child.once('error', reject);
+            child.once('close', code => resolve(code));
+        });
+        let stderr = '';
+        let exitCode = null;
+        try {
+            [stderr, exitCode] = await Promise.all([stderrPromise, exitCodePromise, stdoutPromise]).then(([nextStderr, nextExitCode]) => [nextStderr, nextExitCode]);
+        }
+        catch (error) {
+            const normalized = asError(error);
+            if (aborted || isAbortErrorLike(normalized)) {
+                throw new RunAbortedError('The Actoviq Runtime run was aborted.', { cause: error });
+            }
+            throw new ActoviqBridgeProcessError(normalized.message, { cause: error, stderr, exitCode });
+        }
+        finally {
+            options.signal?.removeEventListener('abort', abort);
+        }
+        if (aborted && !resultEvent) {
+            throw new RunAbortedError('The Actoviq Runtime run was aborted.');
+        }
+        if (!resultEvent) {
+            throw new ActoviqBridgeProcessError(stderr.trim()
+                ? `Actoviq Runtime exited without a result event: ${stderr.trim()}`
+                : 'Actoviq Runtime exited without emitting a result event.', { stderr, exitCode });
+        }
+        const result = {
+            text: deriveResultText(resultEvent, assistantMessages),
+            sessionId: getStringValue(resultEvent, 'session_id') ??
+                getStringValue(initEvent, 'session_id') ??
+                options.sessionId ??
+                (typeof options.resume === 'string' ? options.resume : ''),
+            isError: getBooleanValue(resultEvent, 'is_error') ?? false,
+            subtype: getStringValue(resultEvent, 'subtype'),
+            stopReason: getStringValue(resultEvent, 'stop_reason'),
+            durationMs: getNumberValue(resultEvent, 'duration_ms'),
+            totalCostUsd: getNumberValue(resultEvent, 'total_cost_usd'),
+            numTurns: getNumberValue(resultEvent, 'num_turns'),
+            exitCode,
+            stderr,
+            initEvent,
+            resultEvent,
+            assistantMessages,
+            events,
+        };
+        return result;
+    }
+}
+export async function createActoviqBridgeSdk(options = {}) {
+    return ActoviqBridgeSdkClient.create(options);
+}
+//# sourceMappingURL=actoviqBridgeSdk.js.map