maka-agent 0.2.0-dev.47.20260922 → 0.2.0-dev.48.20260923

package/node_modules/@maka/runtime-host/dist/protocol/plugin-platform.js

@@ -16,6 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+import { normalizeCatalogEntry } from '@maka/core/executor-catalog';
 import { validateCompositionEntry, validatePluginRootId, } from '@maka/runtime/plugin-runtime';
 import { requireCount, requireEncodedByteLimit, requireExactRecord, requireId, requireRecord, requireShapedRecord, requireString, } from './codec.js';
 import { invalidProtocolFrame } from './errors.js';
@@ -85,6 +86,39 @@ export const PLUGIN_PLATFORM_OPERATION_SPECS = {
         decodeInput: decodePluginClientRemoteStreamCursorInput,
         decodeOutput: decodePluginClientRemoteStreamCloseResult,
     }),
+    'plugin.executor.query': defineOperation({
+        mode: 'query',
+        availability: 'ready',
+        errors: QUERY_ERRORS,
+        decodeInput: (value) => {
+            const record = requireRecord(value, 'Executor query');
+            if (record.kind === 'catalog') {
+                const input = requireExactRecord(record, 'Executor catalog', ['kind', 'cwd']);
+                return { kind: 'catalog', cwd: requireString(input.cwd, 'cwd', 4096) };
+            }
+            const input = requireExactRecord(record, 'Executor conversation', ['kind', 'sessionId']);
+            if (input.kind !== 'conversation')
+                throw invalidProtocolFrame('Invalid executor query');
+            return { kind: 'conversation', sessionId: requireId(input.sessionId, 'sessionId') };
+        },
+        decodeOutput: (value) => {
+            requireEncodedByteLimit(value, 'Executor catalog', MAX_FRAME_BYTES);
+            const output = requireExactRecord(value, 'Executor catalog result', ['items']);
+            if (!Array.isArray(output.items) || output.items.length > 256)
+                throw invalidProtocolFrame('Invalid executor catalog');
+            return {
+                items: output.items.map((entry) => {
+                    const record = requireRecord(entry, 'Executor catalog entry');
+                    try {
+                        return normalizeCatalogEntry(record, requireString(record.id, 'executor id', 256));
+                    }
+                    catch {
+                        throw invalidProtocolFrame('Invalid executor catalog entry');
+                    }
+                }),
+            };
+        },
+    }),
     'plugin.platform.query': defineOperation({
         mode: 'query',
         availability: 'ready',

package/node_modules/@maka/runtime-host/dist/protocol/session-catalog.js

@@ -16,6 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+import { isExecutorConfiguration } from '@maka/core/executor-catalog';
 import { isCollaborationMode } from '@maka/core/collaboration';
 import { isOrchestrationMode } from '@maka/core/orchestration';
 import { isPermissionMode } from '@maka/core/permission';
@@ -94,6 +95,7 @@ const PROJECTION_FIELDS = [
     'revisionIndex',
     'revisionState',
     'executorId',
+    'executorConfig',
     'thinkingLevel',
     'lastReadMessageId',
     'liveRunState',
@@ -252,6 +254,7 @@ export function decodeSessionCreateInput(value) {
         'modelTarget',
         'executorId',
         'executorModel',
+        'executorConfig',
         'thinkingLevel',
         'toolProfile',
         'permissionMode',
@@ -261,6 +264,9 @@ export function decodeSessionCreateInput(value) {
     const executorId = Object.hasOwn(input, 'executorId')
         ? executorIdValue(input.executorId)
         : undefined;
+    if (input.executorConfig !== undefined &&
+        (!executorId || !isExecutorConfiguration(input.executorConfig)))
+        throw invalidProtocolFrame('Invalid executor configuration');
     const target = Object.hasOwn(input, 'modelTarget') ? modelTarget(input.modelTarget) : undefined;
     const executorModel = Object.hasOwn(input, 'executorModel')
         ? requireUtf8String(input.executorModel, 'Executor model', SESSION_CATALOG_MODEL_MAX_BYTES)
@@ -268,6 +274,11 @@ export function decodeSessionCreateInput(value) {
     if ((executorId === undefined) === (target === undefined)) {
         throw invalidProtocolFrame('Session creation requires exactly one model target or executor id');
     }
+    if (executorModel !== undefined &&
+        input.executorConfig?.model !== undefined &&
+        executorModel !== input.executorConfig.model) {
+        throw invalidProtocolFrame('Conflicting executor models');
+    }
     if (executorModel !== undefined && executorId === undefined) {
         throw invalidProtocolFrame('Executor model requires an executor id');
     }
@@ -280,6 +291,14 @@ export function decodeSessionCreateInput(value) {
         ...(target ? { modelTarget: target } : {}),
         ...(executorId ? { executorId } : {}),
         ...(executorModel ? { executorModel } : {}),
+        ...(executorId
+            ? {
+                executorId,
+                ...(input.executorConfig
+                    ? { executorConfig: input.executorConfig }
+                    : {}),
+            }
+            : {}),
         ...(Object.hasOwn(input, 'thinkingLevel')
             ? { thinkingLevel: input.thinkingLevel === null ? null : thinkingLevel(input.thinkingLevel) }
             : {}),
@@ -336,6 +355,7 @@ export function decodeSessionConfigurationUpdateInput(value) {
         'patch',
     ]);
     const patch = requireShapedRecord(input.patch, 'Session configuration patch', [], [
+        'executorConfig',
         'modelTarget',
         'executorTarget',
         'thinkingLevel',
@@ -343,6 +363,11 @@ export function decodeSessionConfigurationUpdateInput(value) {
         'collaborationMode',
         'orchestrationMode',
     ]);
+    if (patch.executorConfig !== undefined &&
+        (!isExecutorConfiguration(patch.executorConfig) ||
+            patch.modelTarget !== undefined ||
+            patch.executorTarget !== undefined))
+        throw invalidProtocolFrame('Invalid executor configuration');
     if (Object.keys(patch).length === 0) {
         throw invalidProtocolFrame('Session configuration patch is empty');
     }
@@ -353,6 +378,9 @@ export function decodeSessionConfigurationUpdateInput(value) {
         sessionId: requireEntityId(input.sessionId, 'sessionId'),
         expectedRevision: positiveRevision(input.expectedRevision, 'expected Session revision'),
         patch: {
+            ...(patch.executorConfig
+                ? { executorConfig: patch.executorConfig }
+                : {}),
             ...(Object.hasOwn(patch, 'modelTarget')
                 ? { modelTarget: explicitModelTarget(patch.modelTarget) }
                 : {}),
@@ -692,9 +720,19 @@ function executorTarget(value) {
     };
 }
 function optionalExecutorId(record) {
-    if (record.executorId === undefined)
+    if (record.executorId === undefined) {
+        if (record.executorConfig !== undefined)
+            throw invalidProtocolFrame('Executor configuration requires an executor');
         return {};
-    return { executorId: executorIdValue(record.executorId) };
+    }
+    if (record.executorConfig !== undefined && !isExecutorConfiguration(record.executorConfig))
+        throw invalidProtocolFrame('Invalid executor configuration');
+    return {
+        executorId: executorIdValue(record.executorId),
+        ...(record.executorConfig
+            ? { executorConfig: record.executorConfig }
+            : {}),
+    };
 }
 function thinkingLevel(value) {
     if (!isThinkingLevel(value))

package/node_modules/@maka/runtime-host/dist/server/builtin-external-agent-plugins.js

@@ -0,0 +1,188 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { copyFile, mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { extensionPackageDirectoryContentDigest } from './extension-bundle.js';
+const ACP_RUNTIME_PACKAGE_ID = 'acp-executor';
+const ACP_RUNTIME_ENTRY_ID = 'acp-runtime';
+const ANTIGRAVITY_PACKAGE_ID = 'antigravity-acp';
+const ANTIGRAVITY_ENTRY_ID = 'antigravity-acp';
+const STAGING_DIRECTORY = 'builtin-plugin-staging-v1';
+const RUNTIME_ENTRY = 'plugin.mjs';
+const COMPOSITION_PATCH = 'maka.composition.json';
+// Built-in setup entries remain discoverable before their Plugin is installed.
+// Registered Plugins replace these placeholders with their live catalogs.
+const BUILTIN_EXTERNAL_AGENT_CATALOG = Object.freeze([
+    Object.freeze({
+        id: ANTIGRAVITY_ENTRY_ID,
+        displayName: 'Antigravity',
+        readiness: 'unavailable',
+        models: Object.freeze([]),
+        supportsAttachments: false,
+        supportsModelChange: false,
+    }),
+]);
+export function withBuiltinExternalAgentCatalog(catalog) {
+    const registered = new Set(catalog.map((entry) => entry.id));
+    return [
+        ...catalog,
+        ...BUILTIN_EXTERNAL_AGENT_CATALOG.filter((entry) => !registered.has(entry.id)),
+    ];
+}
+/**
+ * Projects durable product settings into reserved Plugin packages and Entries.
+ *
+ * RuntimePolicy remains the owner of setup facts. The generated package layer
+ * is replaceable derived state, so adapter code never reads RuntimePolicy and
+ * repeated reconciliation does not append unbounded user composition overlays.
+ */
+export class HostBuiltinExternalAgentPluginCoordinator {
+    #platform;
+    #controlDirectory;
+    #readPolicy;
+    #entries;
+    #gate = Promise.resolve();
+    constructor(input) {
+        this.#platform = input.platform;
+        this.#controlDirectory = input.controlDirectory;
+        this.#readPolicy = input.readPolicy;
+        this.#entries = input.entries ?? resolveBuiltinExternalAgentPluginEntries();
+    }
+    async recover() {
+        await rm(join(this.#controlDirectory, STAGING_DIRECTORY), { recursive: true, force: true });
+        return await this.reconcile();
+    }
+    reconcile() {
+        const task = this.#gate.then(() => this.#reconcileNow());
+        this.#gate = task.catch(() => undefined);
+        return task;
+    }
+    async #reconcileNow() {
+        const executable = (await this.#readPolicy()).policy.externalAgents.antigravity.executable;
+        if (!executable) {
+            await this.#removeIfInstalled(ANTIGRAVITY_PACKAGE_ID);
+            await this.#removeIfInstalled(ACP_RUNTIME_PACKAGE_ID);
+            return;
+        }
+        await this.#ensurePackage(ACP_RUNTIME_PACKAGE_ID, this.#entries.acpRuntime, acpRuntimeManifest(), [
+            {
+                type: 'insert',
+                rootId: 'profile',
+                entry: {
+                    id: ACP_RUNTIME_ENTRY_ID,
+                    packageId: ACP_RUNTIME_PACKAGE_ID,
+                    isolate: { acp: true },
+                },
+            },
+        ]);
+        await this.#ensurePackage(ANTIGRAVITY_PACKAGE_ID, this.#entries.antigravity, antigravityManifest(), [
+            {
+                type: 'insert',
+                parentId: ACP_RUNTIME_ENTRY_ID,
+                entry: {
+                    id: ANTIGRAVITY_ENTRY_ID,
+                    packageId: ANTIGRAVITY_PACKAGE_ID,
+                    config: { executable },
+                },
+            },
+        ]);
+    }
+    async #ensurePackage(extensionId, runtimeEntry, manifest, operations) {
+        const staged = await stagePackage(this.#controlDirectory, runtimeEntry, manifest, operations);
+        try {
+            const installed = (await this.#platform.packageProjections()).find((candidate) => candidate.extensionId === extensionId);
+            if (installed?.contentDigest === staged.digest)
+                return;
+            await this.#platform.installPackage(staged.root);
+        }
+        finally {
+            await staged.dispose();
+        }
+    }
+    async #removeIfInstalled(extensionId) {
+        const installed = (await this.#platform.packageProjections()).some((candidate) => candidate.extensionId === extensionId);
+        if (installed)
+            await this.#platform.uninstallPackage(extensionId);
+    }
+}
+export function resolveBuiltinExternalAgentPluginEntries() {
+    return Object.freeze({
+        acpRuntime: fileURLToPath(import.meta.resolve('@maka/acp-executor-plugin/plugin')),
+        antigravity: fileURLToPath(import.meta.resolve('@maka/antigravity-acp-plugin/plugin')),
+    });
+}
+async function stagePackage(controlDirectory, runtimeEntry, manifest, operations) {
+    const stagingRoot = join(controlDirectory, STAGING_DIRECTORY);
+    await mkdir(stagingRoot, { recursive: true, mode: 0o700 });
+    const root = await mkdtemp(join(stagingRoot, '.package-'));
+    try {
+        await copyFile(runtimeEntry, join(root, RUNTIME_ENTRY));
+        await writeFile(join(root, 'maka.extension.json'), `${JSON.stringify(manifest, null, 2)}\n`, {
+            mode: 0o600,
+        });
+        await writeFile(join(root, COMPOSITION_PATCH), `${JSON.stringify(operations, null, 2)}\n`, {
+            mode: 0o600,
+        });
+        return Object.freeze({
+            root,
+            digest: await extensionPackageDirectoryContentDigest(root),
+            dispose: () => rm(root, { recursive: true, force: true }),
+        });
+    }
+    catch (error) {
+        await rm(root, { recursive: true, force: true }).catch(() => undefined);
+        throw error;
+    }
+}
+function acpRuntimeManifest() {
+    return Object.freeze({
+        schemaVersion: 1,
+        id: ACP_RUNTIME_PACKAGE_ID,
+        displayName: 'ACP Executor Runtime',
+        description: 'Shared ACP protocol and process runtime for external Agent adapter plugins.',
+        dependencies: Object.freeze([]),
+        configuration: Object.freeze({ properties: Object.freeze({}), required: Object.freeze([]) }),
+        runtime: Object.freeze({ entry: RUNTIME_ENTRY }),
+        composition: Object.freeze({
+            patch: COMPOSITION_PATCH,
+            structuralDependencies: Object.freeze([]),
+        }),
+    });
+}
+function antigravityManifest() {
+    return Object.freeze({
+        schemaVersion: 1,
+        id: ANTIGRAVITY_PACKAGE_ID,
+        displayName: 'Antigravity ACP',
+        description: 'Runs Google Antigravity as an external Agent through ACP.',
+        dependencies: Object.freeze([{ id: ACP_RUNTIME_PACKAGE_ID }]),
+        configuration: Object.freeze({
+            properties: Object.freeze({
+                executable: Object.freeze({ type: 'string', title: 'ACP executable' }),
+            }),
+            required: Object.freeze(['executable']),
+        }),
+        runtime: Object.freeze({ entry: RUNTIME_ENTRY }),
+        composition: Object.freeze({
+            patch: COMPOSITION_PATCH,
+            structuralDependencies: Object.freeze([ACP_RUNTIME_PACKAGE_ID]),
+        }),
+    });
+}

package/node_modules/@maka/runtime-host/dist/server/candidate.js

@@ -18,10 +18,8 @@
  */
 import { resolveExistingStorageRoot } from '@maka/storage/root-authority';
 import { currentRuntimeHostProcessLaunch, tryAcquireRuntimeHostLaunch, } from '../operator/managed-deployment.js';
-import { RuntimeHostKernel } from './host-kernel.js';
-import { openRuntimeHostAccessAuthority } from './access-authority.js';
-import { startRuntimeHostAuthenticatedListenerSet } from './listener-set.js';
 export async function startInteractiveRuntimeHostCandidate(options, createComposition, dependencies = {}) {
+    const kernelModule = import('./host-kernel.js').then((module) => ({ kind: 'loaded', module }), (error) => ({ kind: 'failed', error }));
     const capability = await resolveExistingStorageRoot({
         path: options.rootPath,
         kind: 'interactive',
@@ -37,9 +35,13 @@ export async function startInteractiveRuntimeHostCandidate(options, createCompos
     const { owner, managedConfig } = ownership;
     try {
         const composition = await createComposition(managedConfig);
+        const loadedKernel = await kernelModule;
+        if (loadedKernel.kind === 'failed')
+            throw loadedKernel.error;
+        const { RuntimeHostKernel } = loadedKernel.module;
         const websocket = managedConfig?.listeners.websocket;
         const accessAuthority = websocket
-            ? await openRuntimeHostAccessAuthority(owner.controlDirectory)
+            ? await import('./access-authority.js').then(({ openRuntimeHostAccessAuthority }) => openRuntimeHostAccessAuthority(owner.controlDirectory))
             : undefined;
         const host = await RuntimeHostKernel.start({
             owner,
@@ -55,9 +57,12 @@ export async function startInteractiveRuntimeHostCandidate(options, createCompos
             ...(accessAuthority ? { accessAuthority } : {}),
             ...(websocket && accessAuthority
                 ? {
-                    listenerSetFactory: (input) => startRuntimeHostAuthenticatedListenerSet(input, {
-                        websocket: { ...websocket, accessAuthority },
-                    }),
+                    listenerSetFactory: async (input) => {
+                        const { startRuntimeHostAuthenticatedListenerSet } = await import('./listener-set.js');
+                        return startRuntimeHostAuthenticatedListenerSet(input, {
+                            websocket: { ...websocket, accessAuthority },
+                        });
+                    },
                 }
                 : {}),
         });

package/node_modules/@maka/runtime-host/dist/server/client-capability-recovery.js

@@ -20,53 +20,51 @@ import { compatibilityToolResultProjection } from '@maka/runtime/durable-tool-re
 const OUTCOME_UNKNOWN_TEXT = 'outcome_unknown: the Host restarted after dispatching this Client Capability call. The client-side effect may have happened; do not retry it automatically.';
 export async function recoverClientCapabilityOutcomes(store, sessionIds, now = Date.now) {
     let recovered = 0;
-    for (const sessionId of sessionIds) {
-        const operations = await store.listUnsettledToolOperations(sessionId);
-        for (const operation of operations) {
-            if (operation.recoveryMode !== 'outcome_unknown')
-                continue;
-            const ts = now();
-            const result = {
-                kind: 'text',
-                text: OUTCOME_UNKNOWN_TEXT,
-                uncertainOutcome: {
-                    code: 'outcome_unknown',
-                    retrySafe: false,
-                },
-            };
-            const responseContent = {
-                kind: 'function_response',
-                id: operation.providerToolCallId,
-                name: operation.toolName,
-                result,
-                isError: true,
-            };
-            const modelProjection = compatibilityToolResultProjection(responseContent, sessionId);
-            const runtimeEvent = {
-                id: `${operation.operationId}_response`,
-                invocationId: operation.invocationId,
-                runId: operation.runId,
-                sessionId,
-                turnId: operation.turnId,
-                ts,
-                partial: false,
-                role: 'tool',
-                author: 'tool',
-                content: { ...responseContent, ...(modelProjection ? { modelProjection } : {}) },
-                refs: {
-                    operationId: operation.operationId,
-                    toolCallId: operation.providerToolCallId,
-                },
-            };
-            const committed = await store.commitToolOutcome({
+    const operations = await store.listUnsettledToolOperations(sessionIds);
+    for (const operation of operations) {
+        if (operation.recoveryMode !== 'outcome_unknown')
+            continue;
+        const ts = now();
+        const result = {
+            kind: 'text',
+            text: OUTCOME_UNKNOWN_TEXT,
+            uncertainOutcome: {
+                code: 'outcome_unknown',
+                retrySafe: false,
+            },
+        };
+        const responseContent = {
+            kind: 'function_response',
+            id: operation.providerToolCallId,
+            name: operation.toolName,
+            result,
+            isError: true,
+        };
+        const modelProjection = compatibilityToolResultProjection(responseContent, operation.sessionId);
+        const runtimeEvent = {
+            id: `${operation.operationId}_response`,
+            invocationId: operation.invocationId,
+            runId: operation.runId,
+            sessionId: operation.sessionId,
+            turnId: operation.turnId,
+            ts,
+            partial: false,
+            role: 'tool',
+            author: 'tool',
+            content: { ...responseContent, ...(modelProjection ? { modelProjection } : {}) },
+            refs: {
                 operationId: operation.operationId,
-                journalEventId: `${operation.operationId}_outcome`,
-                runtimeEvent,
-                committedAt: ts,
-            });
-            if (committed.created)
-                recovered += 1;
-        }
+                toolCallId: operation.providerToolCallId,
+            },
+        };
+        const committed = await store.commitToolOutcome({
+            operationId: operation.operationId,
+            journalEventId: `${operation.operationId}_outcome`,
+            runtimeEvent,
+            committedAt: ts,
+        });
+        if (committed.created)
+            recovered += 1;
     }
     return recovered;
 }

package/node_modules/@maka/runtime-host/dist/server/context-coordinator.js

@@ -150,6 +150,8 @@ export class HostContextCoordinator {
                 return notFound('Session does not exist');
             throw error;
         }
+        if (header.backend === 'plugin-executor')
+            return operationUnavailable('External executors own their context. Start a new task instead of compacting.');
         if (header.isArchived) {
             return sessionArchived('Cannot compact an archived Session');
         }

package/node_modules/@maka/runtime-host/dist/server/execution-composition-factory.js

@@ -16,7 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { defineInteractiveRuntimeHostComposition, } from './host-composition.js';
+import { defineInteractiveRuntimeHostComposition, } from './host-composition-source.js';
 export async function createExecutionRuntimeHostCompositionSource(options, dependencies = {}) {
     const compositionOptions = {
         ...(options.initialization ? { initialization: options.initialization } : {}),