@amalgm/agents 0.1.1 → 0.1.3

package/dist/config/types.js

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

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;
+    }
+}

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

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

package/dist/http/config-routes.js

@@ -0,0 +1,46 @@
+import { isObject } from '../json.js';
+import { importAgentConfig } from '../config/import.js';
+import { configFromAgent, listAgentConfigs, updateAgentConfig } from '../config/store.js';
+function agentId(body) {
+    return typeof body.agent_id === 'string' ? body.agent_id.trim() : '';
+}
+export async function routeAgentConfig(context) {
+    const [resource, action, child] = context.path;
+    if (resource !== 'agent-config')
+        return false;
+    if (!action && context.method === 'GET') {
+        context.json(200, { configs: listAgentConfigs(context.agents) });
+        return true;
+    }
+    if (child || context.method !== 'POST')
+        return false;
+    const body = await context.body();
+    const id = agentId(body);
+    if (!id) {
+        context.json(400, { error: 'agent_id is required' });
+        return true;
+    }
+    const agent = context.agents.getAgent(id);
+    if (!agent) {
+        context.json(404, { error: `Agent not found: ${id}` });
+        return true;
+    }
+    if (action === 'get') {
+        context.json(200, { config: configFromAgent(agent) });
+        return true;
+    }
+    if (action === 'update') {
+        const config = isObject(body.config) ? body.config : {};
+        context.json(200, { ok: true, config: updateAgentConfig(context.agents, id, config).config });
+        return true;
+    }
+    if (action === 'import-native') {
+        const result = importAgentConfig(context.agents, id, {
+            ...(context.nativeHomeDir ? { homeDir: context.nativeHomeDir } : {}),
+            replace: body.replace === true,
+        });
+        context.json(200, { ok: true, ...result });
+        return true;
+    }
+    return false;
+}

package/dist/http/server.js

@@ -1,6 +1,8 @@
 import http from 'node:http';
 import { Agents } from '../agents.js';
 import { asAgentError } from '../errors.js';
+import { routeAgentConfig } from './config-routes.js';
+import { routeAgentBundles } from './bundle-routes.js';
 import { routeAgents } from './agent-routes.js';
 import { guardRequest, readJson, sendJson } from './request.js';
 import { routeSessions } from './session-routes.js';
@@ -44,10 +46,12 @@ export function createRestServer(options = {}) {
             path,
             url,
             skillRoots: options.skillRoots || {},
+            ...(options.nativeHomeDir ? { nativeHomeDir: options.nativeHomeDir } : {}),
+            ...(options.bundlePort ? { bundlePort: options.bundlePort } : {}),
             body: () => readJson(request, bodyLimit),
             json: (status, value) => sendJson(response, status, value),
         };
-        if (await routeSkills(context))
+        if (await routeAgentBundles(context) || await routeAgentConfig(context) || await routeSkills(context))
             return;
         if (path.shift() !== 'v1') {
             sendJson(response, 404, { error: { code: 'not_found', message: 'Route not found.' } });

package/dist/http-types.d.ts

@@ -3,11 +3,14 @@ import type { AddressInfo } from 'node:net';
 import type { Agents } from './agents.js';
 import type { AgentsOptions } from './types.js';
 import type { SkillRootOptions } from './skills/roots.js';
+import type { AgentBundlePort } from './bundles/types.js';
 export interface RestServerOptions extends AgentsOptions {
     agents?: Agents;
     token?: string;
     bodyLimitBytes?: number;
     skillRoots?: SkillRootOptions;
+    nativeHomeDir?: string;
+    bundlePort?: AgentBundlePort;
 }
 export interface RestServer {
     agents: Agents;
@@ -21,6 +24,8 @@ export interface RouteContext {
     path: string[];
     url: URL;
     skillRoots: SkillRootOptions;
+    nativeHomeDir?: string;
+    bundlePort?: AgentBundlePort;
     body(): Promise<Record<string, unknown>>;
     json(status: number, value: unknown): void;
 }

package/dist/index.d.ts

@@ -8,3 +8,15 @@ export { buildCanonicalSkillRoots, classifySkillRoot } from './skills/roots.js';
 export type { SkillRootClassification, SkillRootOptions } from './skills/roots.js';
 export { parseSkillFrontmatter, scanInstalledSkills } from './skills/scanner.js';
 export type { InstalledSkill, SkillScanOptions } from './skills/scanner.js';
+export { normalizeAgentConfig, stableConfigId } from './config/schema.js';
+export { configFromAgent, listAgentConfigs, updateAgentConfig } from './config/store.js';
+export { importAgentConfig } from './config/import.js';
+export { importNativeConfig } from './config/native.js';
+export type * from './config/types.js';
+export { createAgentBundle } from './bundles/create.js';
+export type { CreateBundleOptions } from './bundles/create.js';
+export { installAgentBundle } from './bundles/install.js';
+export { buildBundleGraph } from './bundles/graph.js';
+export { validateAgentBundle } from './bundles/validate.js';
+export { BUNDLE_KIND, BUNDLE_SCHEMA_VERSION } from './bundles/util.js';
+export type * from './bundles/types.js';

package/dist/index.js

@@ -5,3 +5,12 @@ export { definitionHash, normalizeDefinition, patchDefinition } from './definiti
 export { messageText, normalizeMessage } from './messages.js';
 export { buildCanonicalSkillRoots, classifySkillRoot } from './skills/roots.js';
 export { parseSkillFrontmatter, scanInstalledSkills } from './skills/scanner.js';
+export { normalizeAgentConfig, stableConfigId } from './config/schema.js';
+export { configFromAgent, listAgentConfigs, updateAgentConfig } from './config/store.js';
+export { importAgentConfig } from './config/import.js';
+export { importNativeConfig } from './config/native.js';
+export { createAgentBundle } from './bundles/create.js';
+export { installAgentBundle } from './bundles/install.js';
+export { buildBundleGraph } from './bundles/graph.js';
+export { validateAgentBundle } from './bundles/validate.js';
+export { BUNDLE_KIND, BUNDLE_SCHEMA_VERSION } from './bundles/util.js';

package/dist/mcp/server.js

@@ -16,7 +16,7 @@ export function createMcpServer(options = {}) {
             return {
                 protocolVersion: message.params?.protocolVersion || '2024-11-05',
                 capabilities: { tools: { listChanged: false } },
-                serverInfo: { name: 'amalgm-agents', version: '0.1.1' },
+                serverInfo: { name: 'amalgm-agents', version: '0.1.3' },
             };
         }
         if (message.method === 'ping')

package/docs/ENGINE_INTEGRATION.md

@@ -18,9 +18,9 @@ that domain.
 | credential adapter | `authRef` resolver inside drivers |
 | Supabase Chat session creation | Chat/cloud adapter observing Agents events |
 
-Agent bundles currently mix agents, apps, automations, and tool bindings. That
-cross-product packaging concern should remain outside this repository. A bundle
-installer may call each product's public apply method.
+Agent bundle-v2 graph and agent install laws live here. Engine supplies the
+`AgentBundlePort` that exports and installs apps, automations, and tools through
+their public SDKs; neither side imports another product's store.
 
 ## Required driver adapter
 

package/docs/REST.md

@@ -10,6 +10,31 @@ token receives the kernel's canonical 401 from `@amalgm/core/transport`,
 compared in constant time. `/healthz` is a minimal unauthenticated liveness
 response. JSON bodies default to a 512 KB limit.
 
+## Agent configuration
+
+| Method | Path | Result |
+|---|---|---|
+| `GET` | `/agent-config` | List normalized configs from live agent revisions |
+| `POST` | `/agent-config/get` | Read `{ agent_id }` |
+| `POST` | `/agent-config/update` | Atomically apply `{ agent_id, config }` |
+| `POST` | `/agent-config/import-native` | Import safe native fields for `{ agent_id, replace? }` |
+
+Set `nativeHomeDir` when embedding the server or `--native-home`/
+`AMALGM_NATIVE_HOME` with the REST binary. Native import intentionally ignores
+auth files, secrets, and MCP server configuration.
+
+## Agent bundles
+
+| Method | Path | Result |
+|---|---|---|
+| `GET` | `/agent-bundles` | Read bundle-v2 capability and available agent heads |
+| `POST` | `/agent-bundles/preview` | Export requested agent/app/automation/tool heads |
+| `POST` | `/agent-bundles/install` | Validate and install `{ bundle, auth_ref? }` |
+
+Embedding hosts inject `bundlePort` for resources owned by Apps, Automations,
+and Toolbox. Agent-only bundles need no port. Bundles with external resources
+fail explicitly when the owner port is absent.
+
 ## Agents
 
 | Method | Path | Result |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amalgm/agents",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Local-first agent definitions, immutable revisions, and durable sessions.",
   "license": "UNLICENSED",
   "private": false,