@amalgm/agents 0.1.2 → 0.2.0

package/dist/bundles/graph.js

@@ -0,0 +1,121 @@
+import { actionEntryId, agentEntryId, appEntryId, automationEntryId, skillElementId, skillLabel, toolEntryId, } from './graph-records.js';
+import { clean, object, uniqueStrings } from './util.js';
+const ORDER = {
+    agent: 0, automation: 1, app: 2, tool: 3, tool_action: 4, skill: 5,
+};
+function elementId(type, id) {
+    return `${type}:${id}`;
+}
+function graphRecords(bundle) {
+    return {
+        agent: new Map(bundle.agents.map((entry) => [agentEntryId(entry), entry])),
+        automation: new Map(bundle.automations.map((entry) => [automationEntryId(entry), entry])),
+        app: new Map(bundle.apps.map((entry) => [appEntryId(entry), entry])),
+        tool: new Map(bundle.tools.map((entry) => [toolEntryId(entry), entry])),
+        tool_action: new Map(bundle.toolActions.map((entry) => [actionEntryId(entry), entry])),
+        skill: new Map(bundle.skills.map((entry) => [skillElementId(entry), entry])),
+    };
+}
+// Engine reference: amalgm-mcp/agent-bundles/graph.js buildFlatAgentBundleGraph.
+export function buildBundleGraph(bundle) {
+    const records = graphRecords(bundle);
+    const elements = new Map();
+    const edges = new Map();
+    const addElement = (type, id, label) => {
+        const key = elementId(type, id);
+        elements.set(key, { id: key, type, label: label || id });
+    };
+    const addEdge = (fromType, fromId, toType, toId, kind) => {
+        const edge = { from: elementId(fromType, fromId), to: elementId(toType, toId), kind };
+        edges.set(`${edge.from}::${kind}::${edge.to}`, edge);
+    };
+    const requireRecord = (type, id, owner) => {
+        if (!records[type].has(id))
+            throw new Error(`${owner} references missing ${type.replace('_', ' ')}: ${id}`);
+    };
+    const addToolSelection = (ownerType, ownerId, selectedId) => {
+        if (records.tool_action.has(selectedId))
+            addEdge(ownerType, ownerId, 'tool_action', selectedId, 'uses-tool-action');
+        else {
+            requireRecord('tool', selectedId, `${ownerType} ${ownerId}`);
+            addEdge(ownerType, ownerId, 'tool', selectedId, 'uses-tool');
+        }
+    };
+    for (const entry of bundle.agents)
+        addElement('agent', agentEntryId(entry), entry.agent.name);
+    for (const entry of bundle.automations) {
+        addElement('automation', automationEntryId(entry), clean(object(entry.automation)?.name));
+    }
+    for (const entry of bundle.apps)
+        addElement('app', appEntryId(entry), clean(object(entry.app)?.name));
+    for (const entry of bundle.tools)
+        addElement('tool', toolEntryId(entry), clean(entry.name));
+    for (const entry of bundle.toolActions)
+        addElement('tool_action', actionEntryId(entry), clean(entry.name));
+    for (const skill of bundle.skills) {
+        const id = skillElementId(skill);
+        elements.set(id, { id, type: 'skill', label: skillLabel(skill) });
+    }
+    for (const entry of bundle.agents) {
+        const id = agentEntryId(entry);
+        for (const subagent of entry.config.subagents) {
+            if (!subagent.agentId)
+                continue;
+            requireRecord('agent', subagent.agentId, `agent ${id}`);
+            addEdge('agent', id, 'agent', subagent.agentId, 'uses-subagent');
+        }
+        for (const selectedId of entry.config.loadout.toolIds)
+            addToolSelection('agent', id, selectedId);
+        for (const skill of entry.config.skills) {
+            const skillId = skillElementId(skill);
+            if (!records.skill.has(skillId))
+                throw new Error(`agent ${id} references missing skill: ${skillLabel(skill)}`);
+            addEdge('agent', id, 'skill', skillId.slice('skill:'.length), 'uses-skill');
+        }
+    }
+    for (const entry of bundle.automations) {
+        const id = automationEntryId(entry);
+        for (const selectedId of uniqueStrings(entry.toolIds))
+            addToolSelection('automation', id, selectedId);
+    }
+    for (const entry of bundle.apps) {
+        const id = appEntryId(entry);
+        for (const toolId of uniqueStrings(entry.toolIds)) {
+            requireRecord('tool', toolId, `app ${id}`);
+            addEdge('app', id, 'tool', toolId, 'provides-tool');
+        }
+    }
+    for (const tool of bundle.tools) {
+        const id = toolEntryId(tool);
+        const appId = clean(tool.appId);
+        if (appId) {
+            requireRecord('app', appId, `tool ${id}`);
+            addEdge('tool', id, 'app', appId, 'requires-app');
+        }
+    }
+    for (const action of bundle.toolActions) {
+        const id = actionEntryId(action);
+        const toolId = clean(action.toolId);
+        requireRecord('tool', toolId, `tool action ${id}`);
+        addEdge('tool', toolId, 'tool_action', id, 'has-action');
+        addEdge('tool_action', id, 'tool', toolId, 'action-of');
+        const appId = clean(action.appId);
+        if (appId) {
+            requireRecord('app', appId, `tool action ${id}`);
+            addEdge('tool_action', id, 'app', appId, 'requires-app');
+        }
+    }
+    const headIds = bundle.heads.map((head) => {
+        const id = elementId(head.type, head.id);
+        if (!elements.has(id))
+            throw new Error(`bundle head references missing element: ${id}`);
+        return id;
+    });
+    return {
+        headIds,
+        elements: [...elements.values()].sort((left, right) => (ORDER[left.type] ?? 99) - (ORDER[right.type] ?? 99)
+            || left.id.localeCompare(right.id)),
+        edges: [...edges.values()].sort((left, right) => left.from.localeCompare(right.from)
+            || left.kind.localeCompare(right.kind) || left.to.localeCompare(right.to)),
+    };
+}

package/dist/bundles/install.d.ts

@@ -0,0 +1,6 @@
+import type { Agents } from '../agents.js';
+import type { AgentBundlePort, BundleInstallResult } from './types.js';
+export declare function installAgentBundle(agents: Agents, input: unknown, options?: {
+    port?: AgentBundlePort;
+    authRef?: string;
+}): Promise<BundleInstallResult>;

package/dist/bundles/install.js

@@ -0,0 +1,64 @@
+import crypto from 'node:crypto';
+import { normalizeAgentConfig } from '../config/schema.js';
+import { updateAgentConfig } from '../config/store.js';
+import { validateAgentBundle } from './validate.js';
+function uniqueName(agents, value) {
+    const base = value.trim() || 'Imported agent';
+    const names = new Set(agents.listAgents().map((item) => item.definition.name.toLowerCase()));
+    if (!names.has(base.toLowerCase()))
+        return base;
+    if (!names.has(`${base} (imported)`.toLowerCase()))
+        return `${base} (imported)`;
+    for (let index = 2; index < 1000; index += 1) {
+        const candidate = `${base} (imported ${index})`;
+        if (!names.has(candidate.toLowerCase()))
+            return candidate;
+    }
+    return `${base} (${crypto.randomUUID().slice(0, 8)})`;
+}
+// Engine reference: amalgm-mcp/agent-bundles/install.js installBundleAgents.
+export async function installAgentBundle(agents, input, options = {}) {
+    const bundle = validateAgentBundle(input);
+    const hasExternal = bundle.automations.length || bundle.apps.length || bundle.tools.length;
+    if (hasExternal && !options.port)
+        throw new Error('A bundle resource port is required to install external resources');
+    const external = options.port ? await options.port.installResources(bundle) : {};
+    const idMap = new Map();
+    const created = [];
+    for (const entry of bundle.agents) {
+        const agent = agents.createAgent({
+            id: `imported-${crypto.randomUUID()}`,
+            name: uniqueName(agents, entry.agent.name),
+            description: entry.agent.description,
+            driver: { id: entry.agent.driverId, config: {} },
+            model: entry.agent.modelId ? { id: entry.agent.modelId, settings: entry.agent.modelSettings || {} } : null,
+            authRef: options.authRef || null,
+            instructions: entry.config.instructions,
+            resources: { files: [], skills: [], subagents: [] },
+            toolbox: { toolIds: entry.config.loadout.toolIds, actionIds: [] },
+            metadata: { installedFromBundle: bundle.bundleId },
+        });
+        idMap.set(entry.sourceAgentId, agent.id);
+        created.push({ sourceId: entry.sourceAgentId, agent, config: entry.config });
+    }
+    const installedAgents = created.map(({ agent, config }) => {
+        const rewritten = normalizeAgentConfig({
+            ...config,
+            agentId: agent.id,
+            subagents: config.subagents.map((subagent) => ({
+                ...subagent,
+                agentId: idMap.get(subagent.agentId) || '',
+            })).filter((subagent) => subagent.agentId),
+        });
+        return updateAgentConfig(agents, agent.id, rewritten).agent;
+    });
+    return {
+        ok: true,
+        bundleId: bundle.bundleId,
+        rootAgentId: bundle.rootAgentId ? idMap.get(bundle.rootAgentId) || null : installedAgents[0]?.id || null,
+        idMap: Object.fromEntries(idMap),
+        installedAgents,
+        ...external,
+        warnings: [...(bundle.warnings || []), ...(external.warnings || [])],
+    };
+}

package/dist/bundles/types.d.ts

@@ -0,0 +1,97 @@
+import type { AgentConfig } from '../config/types.js';
+import type { AgentRecord, JsonObject } from '../types.js';
+export type BundleHeadType = 'agent' | 'automation' | 'app' | 'tool';
+export interface BundleHead {
+    type: BundleHeadType;
+    id: string;
+}
+export interface BundleAgentEntry {
+    sourceAgentId: string;
+    agent: {
+        name: string;
+        description: string;
+        driverId: string;
+        modelId: string;
+        modelSettings: JsonObject | null;
+    };
+    config: AgentConfig;
+}
+export interface BundleGraphElement {
+    id: string;
+    type: string;
+    label: string;
+}
+export interface BundleGraphEdge {
+    from: string;
+    to: string;
+    kind: string;
+}
+export interface BundleRequirements {
+    runtimes: string[];
+    auth: string[];
+    secrets: string[];
+    bindings: string[];
+    systemTools: string[];
+    systemActions: string[];
+    missingTools: string[];
+}
+export interface AgentBundle {
+    kind: 'amalgm.bundle';
+    schemaVersion: 2;
+    bundleId: string;
+    createdAt: string;
+    rootAgentId: string | null;
+    heads: BundleHead[];
+    headIds: string[];
+    title: string;
+    description: string;
+    agents: BundleAgentEntry[];
+    automations: JsonObject[];
+    apps: JsonObject[];
+    tools: JsonObject[];
+    toolActions: JsonObject[];
+    skills: JsonObject[];
+    assets: JsonObject[];
+    requires: BundleRequirements;
+    warnings: string[];
+    summary: JsonObject;
+    elements: BundleGraphElement[];
+    edges: BundleGraphEdge[];
+}
+export interface BundleExternalExport {
+    headToolIds?: string[];
+    automations?: JsonObject[];
+    apps?: JsonObject[];
+    tools?: JsonObject[];
+    toolActions?: JsonObject[];
+    requires?: Partial<BundleRequirements>;
+    warnings?: string[];
+}
+export interface BundleExternalInstall {
+    installedAutomations?: JsonObject[];
+    installedApps?: JsonObject[];
+    installedTools?: JsonObject[];
+    warnings?: string[];
+}
+export interface AgentBundlePort {
+    exportResources(input: {
+        automationIds: string[];
+        appIds: string[];
+        toolIds: string[];
+    }): Promise<BundleExternalExport> | BundleExternalExport;
+    installResources(bundle: AgentBundle): Promise<BundleExternalInstall> | BundleExternalInstall;
+}
+export interface BundleCreateInput {
+    agentIds?: string[];
+    automationIds?: string[];
+    appIds?: string[];
+    toolIds?: string[];
+}
+export interface BundleInstallResult extends BundleExternalInstall {
+    ok: true;
+    bundleId: string;
+    rootAgentId: string | null;
+    idMap: Record<string, string>;
+    installedAgents: AgentRecord[];
+    warnings: string[];
+}

package/dist/bundles/types.js

@@ -0,0 +1 @@
+export {};

package/dist/bundles/util.d.ts

@@ -0,0 +1,14 @@
+import type { JsonObject, JsonValue } from '../types.js';
+import type { BundleRequirements } from './types.js';
+export declare const BUNDLE_KIND: "amalgm.bundle";
+export declare const BUNDLE_SCHEMA_VERSION: 2;
+export declare function clean(value: unknown): string;
+export declare function object(value: unknown): JsonObject | null;
+export declare function clone<T>(value: T): T;
+export declare function uniqueStrings(value: unknown): string[];
+export declare function addUnique(target: string[], value: string): void;
+export declare function bundleId(): string;
+export declare function digest(value: unknown): string;
+export declare function emptyRequirements(): BundleRequirements;
+export declare function mergeRequirements(target: BundleRequirements, incoming?: Partial<BundleRequirements>): BundleRequirements;
+export declare function scrubSecrets(value: JsonValue, path: string, requires: BundleRequirements): JsonValue;

package/dist/bundles/util.js

@@ -0,0 +1,56 @@
+import crypto from 'node:crypto';
+export const BUNDLE_KIND = 'amalgm.bundle';
+export const BUNDLE_SCHEMA_VERSION = 2;
+export function clean(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+export function object(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+}
+export function clone(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+export function uniqueStrings(value) {
+    if (!Array.isArray(value))
+        return [];
+    return [...new Set(value.map(clean).filter(Boolean))];
+}
+export function addUnique(target, value) {
+    if (value && !target.includes(value))
+        target.push(value);
+}
+export function bundleId() {
+    return `agent-bundle-${crypto.randomUUID()}`;
+}
+export function digest(value) {
+    return crypto.createHash('sha256').update(typeof value === 'string' ? value : JSON.stringify(value))
+        .digest('hex').slice(0, 16);
+}
+export function emptyRequirements() {
+    return { runtimes: [], auth: [], secrets: [], bindings: [], systemTools: [],
+        systemActions: [], missingTools: [] };
+}
+export function mergeRequirements(target, incoming = {}) {
+    for (const key of Object.keys(target)) {
+        for (const value of incoming[key] || [])
+            addUnique(target[key], value);
+    }
+    return target;
+}
+const SECRET = /(api[_-]?key|authorization|bearer|cookie|password|passwd|secret|token|credential|private[_-]?key)/i;
+export function scrubSecrets(value, path, requires) {
+    if (Array.isArray(value))
+        return value.map((item, index) => scrubSecrets(item, `${path}[${index}]`, requires));
+    const record = object(value);
+    if (!record)
+        return value;
+    const output = {};
+    for (const [key, child] of Object.entries(record)) {
+        const childPath = path ? `${path}.${key}` : key;
+        if (SECRET.test(key))
+            addUnique(requires.secrets, childPath);
+        else
+            output[key] = scrubSecrets(child, childPath, requires);
+    }
+    return output;
+}

package/dist/bundles/validate.d.ts

@@ -0,0 +1,2 @@
+import type { AgentBundle } from './types.js';
+export declare function validateAgentBundle(input: unknown): AgentBundle;

package/dist/bundles/validate.js

@@ -0,0 +1,92 @@
+import { actionEntryId, agentEntryId, appEntryId, automationEntryId, skillFingerprint, toolEntryId } from './graph-records.js';
+import { buildBundleGraph } from './graph.js';
+import { BUNDLE_KIND, BUNDLE_SCHEMA_VERSION, clean, object } from './util.js';
+function unique(label, records, identify) {
+    const seen = new Set();
+    for (const record of records) {
+        const id = identify(record);
+        if (!id)
+            throw new Error(`${label} entries must include ids`);
+        if (seen.has(id))
+            throw new Error(`Bundle contains duplicate ${label} id: ${id}`);
+        seen.add(id);
+    }
+}
+function assertClosed(bundle) {
+    const elements = new Set();
+    for (const element of bundle.elements) {
+        if (!clean(element.id) || !clean(element.type))
+            throw new Error('bundle graph elements must include id and type');
+        if (object(element)?.data !== undefined)
+            throw new Error(`bundle graph element must not copy data: ${element.id}`);
+        if (elements.has(element.id))
+            throw new Error(`bundle graph contains duplicate element id: ${element.id}`);
+        elements.add(element.id);
+    }
+    const outgoing = new Map();
+    const edgeKeys = new Set();
+    for (const edge of bundle.edges) {
+        if (!elements.has(edge.from) || !elements.has(edge.to))
+            throw new Error('bundle graph edge references missing element');
+        const key = `${edge.from}::${edge.kind}::${edge.to}`;
+        if (edgeKeys.has(key))
+            throw new Error(`bundle graph contains duplicate edge: ${key}`);
+        edgeKeys.add(key);
+        outgoing.set(edge.from, [...(outgoing.get(edge.from) || []), edge.to]);
+    }
+    const reachable = new Set();
+    const pending = [...bundle.headIds];
+    while (pending.length) {
+        const id = pending.pop();
+        if (reachable.has(id))
+            continue;
+        reachable.add(id);
+        pending.push(...(outgoing.get(id) || []));
+    }
+    const unreachable = [...elements].filter((id) => !reachable.has(id));
+    if (unreachable.length)
+        throw new Error(`bundle graph contains unreachable elements: ${unreachable.join(', ')}`);
+}
+// Engine reference: amalgm-mcp/agent-bundles/install.js validateBundle.
+export function validateAgentBundle(input) {
+    const raw = object(input);
+    if (!raw)
+        throw new Error('bundle must be an object');
+    if (raw.kind !== BUNDLE_KIND)
+        throw new Error(`Unsupported bundle kind: ${clean(raw.kind) || 'unknown'}`);
+    if (raw.schemaVersion !== BUNDLE_SCHEMA_VERSION) {
+        throw new Error(`Unsupported bundle schema version: ${String(raw.schemaVersion || 'unknown')}`);
+    }
+    const bundle = input;
+    const arrays = ['agents', 'automations', 'apps', 'tools', 'toolActions', 'skills', 'heads'];
+    if (arrays.some((key) => !Array.isArray(bundle[key])))
+        throw new Error('bundle canonical records must be arrays');
+    if (!bundle.heads.length)
+        throw new Error('bundle must include at least one head');
+    unique('agent', bundle.agents, agentEntryId);
+    unique('automation', bundle.automations, automationEntryId);
+    unique('app', bundle.apps, appEntryId);
+    unique('tool', bundle.tools, toolEntryId);
+    unique('tool action', bundle.toolActions, actionEntryId);
+    unique('skill', bundle.skills, skillFingerprint);
+    unique('head', bundle.heads, (value) => {
+        const head = object(value);
+        return ['agent', 'automation', 'app', 'tool'].includes(clean(head?.type))
+            ? `${clean(head?.type)}:${clean(head?.id)}` : '';
+    });
+    if (bundle.requires?.missingTools?.length) {
+        throw new Error(`Bundle is missing tools: ${bundle.requires.missingTools.join(', ')}`);
+    }
+    const expected = buildBundleGraph(bundle);
+    const expectedRoot = bundle.heads.find((head) => head.type === 'agent')?.id || null;
+    if (bundle.rootAgentId !== expectedRoot) {
+        throw new Error('bundle rootAgentId does not match its canonical records and connections');
+    }
+    for (const key of ['headIds', 'elements', 'edges']) {
+        if (JSON.stringify(bundle[key]) !== JSON.stringify(expected[key])) {
+            throw new Error(`bundle ${key} does not match its canonical records and connections`);
+        }
+    }
+    assertClosed(bundle);
+    return bundle;
+}

package/dist/cli/help.d.ts

@@ -1 +1 @@
-export declare const HELP = "amalgm-agents \u2014 local agent definitions and durable sessions\n\nAgent definitions:\n  amalgm-agents agent list [--include-deleted]\n  amalgm-agents agent show <id>\n  amalgm-agents agent create <definition.json>\n  amalgm-agents agent update <id> <patch.json>\n  amalgm-agents agent delete <id>\n\nSessions:\n  amalgm-agents session list [--agent <id>] [--include-archived]\n  amalgm-agents session start <agent-id> [--id <id>] [--revision <id>]\n  amalgm-agents session show <id>\n  amalgm-agents session events <id> [--after <sequence>]\n  amalgm-agents session send <id> <message> [--key <idempotency-key>]\n  amalgm-agents session cancel <id>\n  amalgm-agents session archive <id>\n  amalgm-agents talk <agent-id> <message> [--session <id>] [--background]\n\nGlobal options:\n  --state-dir <path>       Agents state directory\n  --drivers <a.js,b.js>    Driver modules (or AMALGM_AGENT_DRIVERS)\n  --help                   Show this help\n";
+export declare const HELP = "amalgm-agents \u2014 local agent identities and immutable revisions\n\nAgents:\n  amalgm-agents agent list [--include-deleted]\n  amalgm-agents agent show <id>\n  amalgm-agents agent create <definition.json>\n  amalgm-agents agent update <id> <patch.json>\n  amalgm-agents agent delete <id>\n\nGlobal options:\n  --state-dir <path>       Agents state directory\n  --help                   Show this help\n";

package/dist/cli/help.js

@@ -1,24 +1,13 @@
-export const HELP = `amalgm-agents — local agent definitions and durable sessions
+export const HELP = `amalgm-agents — local agent identities and immutable revisions
 
-Agent definitions:
+Agents:
   amalgm-agents agent list [--include-deleted]
   amalgm-agents agent show <id>
   amalgm-agents agent create <definition.json>
   amalgm-agents agent update <id> <patch.json>
   amalgm-agents agent delete <id>
 
-Sessions:
-  amalgm-agents session list [--agent <id>] [--include-archived]
-  amalgm-agents session start <agent-id> [--id <id>] [--revision <id>]
-  amalgm-agents session show <id>
-  amalgm-agents session events <id> [--after <sequence>]
-  amalgm-agents session send <id> <message> [--key <idempotency-key>]
-  amalgm-agents session cancel <id>
-  amalgm-agents session archive <id>
-  amalgm-agents talk <agent-id> <message> [--session <id>] [--background]
-
 Global options:
   --state-dir <path>       Agents state directory
-  --drivers <a.js,b.js>    Driver modules (or AMALGM_AGENT_DRIVERS)
   --help                   Show this help
 `;

package/dist/cli/open.d.ts

@@ -1,3 +1,3 @@
 import { Agents } from '../agents.js';
 import type { ParsedArgs } from './args.js';
-export declare function openAgents(args: ParsedArgs): Promise<Agents>;
+export declare function openAgents(args: ParsedArgs): Agents;

package/dist/cli/open.js

@@ -1,12 +1,8 @@
 import { Agents } from '../agents.js';
-import { driverSpecifiers, loadDriverModules } from '../drivers.js';
 import { flag } from './args.js';
-export async function openAgents(args) {
-    const modules = flag(args, 'drivers');
+export function openAgents(args) {
     const stateDir = flag(args, 'state-dir');
-    const drivers = await loadDriverModules(driverSpecifiers(modules));
     return new Agents({
-        drivers,
         ...(stateDir ? { stateDir } : {}),
     });
 }

package/dist/cli/run.js

@@ -4,7 +4,6 @@ import { runAgentCommand } from './agent-commands.js';
 import { writeJson } from './files.js';
 import { HELP } from './help.js';
 import { openAgents } from './open.js';
-import { runSessionCommand, runTalkCommand } from './session-commands.js';
 export async function runCli(argv = process.argv.slice(2)) {
     const args = parseArgs(argv);
     if (args.flags.has('help') || args.words.length === 0) {
@@ -13,15 +12,11 @@ export async function runCli(argv = process.argv.slice(2)) {
     }
     let agents;
     try {
-        agents = await openAgents(args);
+        agents = openAgents(args);
         const command = args.words[0];
         const value = command === 'agent'
             ? runAgentCommand(agents, args)
-            : command === 'session'
-                ? await runSessionCommand(agents, args)
-                : command === 'talk'
-                    ? await runTalkCommand(agents, args)
-                    : undefined;
+            : undefined;
         if (value === undefined)
             throw new Error(`Unknown command: ${String(command)}`);
         writeJson(value);
@@ -33,6 +28,6 @@ export async function runCli(argv = process.argv.slice(2)) {
         return 1;
     }
     finally {
-        await agents?.close();
+        agents?.close();
     }
 }

package/dist/errors.d.ts

@@ -1,5 +1,5 @@
 import type { JsonObject } from './types.js';
-export type AgentErrorCode = 'invalid_input' | 'not_found' | 'conflict' | 'deleted' | 'driver_unavailable' | 'too_large' | 'cancelled' | 'internal';
+export type AgentErrorCode = 'invalid_input' | 'not_found' | 'conflict' | 'deleted' | 'too_large' | 'internal';
 export declare class AgentError extends Error {
     readonly code: AgentErrorCode;
     readonly details: JsonObject;

package/dist/errors.js

@@ -3,9 +3,7 @@ const statusByCode = {
     not_found: 404,
     conflict: 409,
     deleted: 410,
-    driver_unavailable: 503,
     too_large: 413,
-    cancelled: 409,
     internal: 500,
 };
 export class AgentError extends Error {

package/dist/http/bundle-routes.d.ts

@@ -0,0 +1,2 @@
+import type { RouteContext } from '../http-types.js';
+export declare function routeAgentBundles(context: RouteContext): Promise<boolean>;

package/dist/http/bundle-routes.js

@@ -0,0 +1,67 @@
+import { createAgentBundle } from '../bundles/create.js';
+import { installAgentBundle } from '../bundles/install.js';
+import { BUNDLE_KIND, BUNDLE_SCHEMA_VERSION } from '../bundles/util.js';
+import { scanInstalledSkills } from '../skills/scanner.js';
+function ids(...values) {
+    const result = [];
+    for (const value of values) {
+        if (typeof value === 'string' && value.trim())
+            result.push(value.trim());
+        if (Array.isArray(value))
+            value.forEach((item) => {
+                if (typeof item === 'string' && item.trim())
+                    result.push(item.trim());
+            });
+    }
+    return [...new Set(result)];
+}
+export async function routeAgentBundles(context) {
+    const [resource, action, child] = context.path;
+    if (resource !== 'agent-bundles')
+        return false;
+    if (!action && context.method === 'GET') {
+        context.json(200, {
+            kind: BUNDLE_KIND,
+            schemaVersion: BUNDLE_SCHEMA_VERSION,
+            available: { agents: context.agents.listAgents().map((agent) => ({
+                    id: agent.id, name: agent.definition.name, description: agent.definition.description,
+                })) },
+        });
+        return true;
+    }
+    if (child || context.method !== 'POST')
+        return false;
+    const body = await context.body();
+    try {
+        if (action === 'preview') {
+            const installedSkills = scanInstalledSkills({ ...context.skillRoots, includeContent: true }).skills;
+            const result = await createAgentBundle(context.agents, {
+                agentIds: ids(body.agent_id, body.agent_ids),
+                automationIds: ids(body.automation_id, body.automation_ids),
+                appIds: ids(body.app_id, body.app_ids),
+                toolIds: ids(body.tool_id, body.tool_ids),
+            }, { ...(context.bundlePort ? { port: context.bundlePort } : {}), installedSkills });
+            context.json(200, { ok: true, ...result });
+            return true;
+        }
+        if (action === 'install') {
+            if (!body.bundle) {
+                context.json(400, { error: 'bundle is required' });
+                return true;
+            }
+            const authRef = typeof body.auth_ref === 'string' ? body.auth_ref
+                : typeof body.authMethod === 'string' ? body.authMethod : undefined;
+            const result = await installAgentBundle(context.agents, body.bundle, {
+                ...(context.bundlePort ? { port: context.bundlePort } : {}),
+                ...(authRef ? { authRef } : {}),
+            });
+            context.json(200, result);
+            return true;
+        }
+        return false;
+    }
+    catch (error) {
+        context.json(400, { error: error instanceof Error ? error.message : 'Bundle operation failed' });
+        return true;
+    }
+}