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

package/DISCLAIMER-WIP

@@ -11,7 +11,12 @@ policy. For example, releases may have incomplete or un-reviewed licensing
 conditions. What follows is a list of issues the project is currently aware of
 (this list is likely to be incomplete):
 
- * The software grant and committer ICLAs are not yet complete.
+ * The initial-code authorization review remains open at
+   https://github.com/apache/maka/issues/3268. Since RC1, the ASF has recorded
+   the ICLA of contributor Mingqwqqaq, and the Deep Research implementation
+   has been removed. The review still needs to record the authorization basis
+   for the retained initial code; these changes do not establish that an SGA
+   has been filed.
 
 If you are planning to incorporate this work into your product/project, please
 be aware that you will need to conduct a thorough licensing review to determine

package/README.md

@@ -47,7 +47,12 @@ policy. For example, releases may have incomplete or un-reviewed licensing
 conditions. What follows is a list of issues the project is currently aware of
 (this list is likely to be incomplete):
 
- * The software grant and committer ICLAs are not yet complete.
+ * The initial-code authorization review remains open at
+   https://github.com/apache/maka/issues/3268. Since RC1, the ASF has recorded
+   the ICLA of contributor Mingqwqqaq, and the Deep Research implementation
+   has been removed. The review still needs to record the authorization basis
+   for the retained initial code; these changes do not establish that an SGA
+   has been filed.
 
 If you are planning to incorporate this work into your product/project, please
 be aware that you will need to conduct a thorough licensing review to determine

package/dist/acp/maka-acp-agent.js

@@ -29,7 +29,7 @@ export function createMakaAcpAgent(options) {
             agentInfo: { name: 'maka', title: 'Maka', version: options.version },
         };
     })
-        .onRequest(methods.agent.session.new, ({ params }) => options.sessionRegistry.create(params))
+        .onRequest(methods.agent.session.new, ({ params, signal }) => options.sessionRegistry.create(params, signal))
         .onRequest(methods.agent.session.list, ({ params }) => options.sessionRegistry.list(params))
         .onRequest(methods.agent.session.setConfigOption, ({ params }) => options.sessionRegistry.setConfigOption(params))
         .onRequest(methods.agent.session.prompt, ({ params, signal, client }) => options.sessionRegistry.prompt(params, {

package/dist/acp/session-mcp.js

@@ -0,0 +1,212 @@
+/*
+ * 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 { isAbsolute } from 'node:path';
+import { RequestError } from '@agentclientprotocol/sdk';
+import { MCP_CONFIG_VERSION } from '@maka/core/mcp';
+import { McpClientManager } from '@maka/mcp';
+import { normalizeMcpConfig } from '@maka/storage/mcp-config-store';
+import { abortable } from '@maka/runtime-host/client';
+import { createMcpCapabilityProvider } from '../mcp-capability-provider.js';
+import { McpCapabilityPublication } from '../mcp-capability-publication.js';
+/** Validates before any process or Host work; never writes a user MCP configuration. */
+export function createAcpMcpConfig(params) {
+    const servers = Object.create(null);
+    if (!Array.isArray(params.mcpServers))
+        throw invalidMcpInput('invalid_servers');
+    for (const server of params.mcpServers) {
+        if (!server || typeof server !== 'object' || 'type' in server || !('command' in server)) {
+            throw invalidMcpInput('unsupported_transport');
+        }
+        if (typeof server.name !== 'string' || Object.hasOwn(servers, server.name)) {
+            throw invalidMcpInput('duplicate_or_invalid_name');
+        }
+        if (typeof server.command !== 'string' ||
+            !isAbsolute(server.command) ||
+            server.command.includes('\0')) {
+            throw invalidMcpInput('command_must_be_absolute');
+        }
+        if (!Array.isArray(server.args) ||
+            server.args.some((arg) => typeof arg !== 'string' || arg.includes('\0'))) {
+            throw invalidMcpInput('invalid_arguments');
+        }
+        if (!Array.isArray(server.env))
+            throw invalidMcpInput('invalid_environment');
+        const env = Object.create(null);
+        for (const variable of server.env) {
+            if (!variable ||
+                typeof variable.name !== 'string' ||
+                variable.name.length === 0 ||
+                variable.name.includes('\0') ||
+                variable.name.includes('=') ||
+                Object.hasOwn(env, variable.name) ||
+                typeof variable.value !== 'string' ||
+                variable.value.includes('\0')) {
+                throw invalidMcpInput('duplicate_or_invalid_environment');
+            }
+            env[variable.name] = variable.value;
+        }
+        servers[server.name] = {
+            command: server.command,
+            args: server.args,
+            env,
+            cwd: params.cwd,
+            protocol: 'auto',
+        };
+    }
+    try {
+        return normalizeMcpConfig({ version: MCP_CONFIG_VERSION, mcpServers: servers });
+    }
+    catch {
+        throw invalidMcpInput('invalid_configuration');
+    }
+}
+/** Owns one Session's in-memory MCP processes and publication on the shared Host connection. */
+export class AcpSessionMcp {
+    #sessionId;
+    #config;
+    #manager = new McpClientManager({
+        clientName: 'maka-acp',
+        excludedStdioEnvironmentKeys: ['MAKA_RUNTIME_HOST_ACCESS_CREDENTIAL'],
+    });
+    #publication;
+    #unsubscribeManager;
+    #unsubscribeConnection;
+    #availability;
+    #prepared = false;
+    #closed = false;
+    #authoritativelyRetired = false;
+    #closeTask;
+    constructor(sessionId, config, connection) {
+        this.#sessionId = sessionId;
+        this.#config = config;
+        this.#publication = new McpCapabilityPublication({
+            connectionIdentity: () => this.#availability?.kind === 'connected'
+                ? this.#availability.hostEpoch + '\0' + this.#availability.connectionId
+                : undefined,
+            revision: () => this.#manager.toolSnapshot().revision,
+            createProvider: () => createMcpCapabilityProvider(this.#manager, {
+                admission: 'mcp',
+                onCurrentRegistrationRetired: () => this.#retire(),
+            }) ?? {
+                // Empty is still an authoritative Session snapshot. Publish it on a
+                // new connection to clear lost Host contracts, and retain retirement
+                // notification even while every configured server has no tools.
+                offers: () => [],
+                currentRegistrationRetired: () => this.#retire(),
+            },
+            replace: (provider) => connection.replaceClientCapabilities(provider, { sessionId }),
+            unregister: () => connection.unregisterClientCapabilities({ sessionId }),
+            onState: () => undefined,
+        });
+        this.#unsubscribeManager = this.#manager.onChange(() => {
+            if (this.#prepared && !this.#closed)
+                this.#publication.request();
+        });
+        this.#unsubscribeConnection = connection.subscribeConnectionAvailability((availability) => {
+            this.#availability = availability;
+            if (availability.kind !== 'connected')
+                this.#publication.invalidate();
+            if (this.#prepared && !this.#closed)
+                this.#publication.request();
+        });
+    }
+    async prepare(signal) {
+        signal?.throwIfAborted();
+        const cancel = () => {
+            void this.close().catch(() => undefined);
+        };
+        signal?.addEventListener('abort', cancel, { once: true });
+        try {
+            await this.#manager.sync(this.#config);
+            signal?.throwIfAborted();
+            this.#assertConnected();
+            this.#prepared = true;
+            await this.ready(signal);
+            this.#assertConnected();
+        }
+        catch (error) {
+            await this.close().catch(() => undefined);
+            if (error instanceof RequestError)
+                throw error;
+            throw mcpUnavailable(this.#sessionId, 'mcp.prepare', 'mcp_preparation_failed');
+        }
+        finally {
+            signal?.removeEventListener('abort', cancel);
+        }
+    }
+    async ready(signal) {
+        signal?.throwIfAborted();
+        this.#assertOpen('mcp.ready');
+        const state = await abortable(() => this.#publication.settle(), signal);
+        signal?.throwIfAborted();
+        this.#assertOpen('mcp.ready');
+        if (state !== 'published' && state !== 'not_published') {
+            throw mcpUnavailable(this.#sessionId, 'mcp.ready', 'mcp_publication_failed');
+        }
+    }
+    close() {
+        return this.#close(true);
+    }
+    #retire() {
+        this.#authoritativelyRetired = true;
+        return this.#close(false);
+    }
+    #close(unregister) {
+        if (this.#closeTask)
+            return this.#closeTask;
+        this.#closed = true;
+        this.#unsubscribeManager();
+        this.#unsubscribeConnection();
+        const managerClose = this.#manager.close();
+        this.#closeTask = (async () => {
+            try {
+                try {
+                    await (unregister ? this.#publication.close() : this.#publication.retire());
+                }
+                catch (error) {
+                    // Session retirement is authoritative. If it wins the race with a local
+                    // unregister, the obsolete unregister may reject even though withdrawal
+                    // has already completed on the Host.
+                    if (!this.#authoritativelyRetired)
+                        throw error;
+                }
+            }
+            finally {
+                await managerClose;
+            }
+        })();
+        return this.#closeTask;
+    }
+    #assertConnected() {
+        this.#assertOpen('mcp.prepare');
+        if (Object.keys(this.#config.mcpServers).some((serverId) => this.#manager.status(serverId)?.state !== 'connected')) {
+            throw mcpUnavailable(this.#sessionId, 'mcp.prepare', 'mcp_not_ready');
+        }
+    }
+    #assertOpen(operation) {
+        if (this.#closed)
+            throw mcpUnavailable(this.#sessionId, operation, 'mcp_not_ready');
+    }
+}
+function invalidMcpInput(reason) {
+    return RequestError.invalidParams({ field: 'mcpServers', reason }, 'Invalid ACP stdio MCP configuration');
+}
+function mcpUnavailable(sessionId, operation, code) {
+    return RequestError.internalError({ source: 'adapter', operation, sessionId, code }, 'Session MCP tools are unavailable');
+}

package/dist/acp/session-registry.js

@@ -28,6 +28,7 @@ import { RuntimeHostSessionUpdateError, getRuntimeHostSession, requireRuntimeHos
 import { AcpSessionConfigInputError, createAcpSessionConfigPatch, projectAcpSessionConfigOptions, validateAcpSessionConfigOptionRequest, } from './session-configuration.js';
 import { AcpSessionEventMapper } from './session-event-mapper.js';
 import { mapAcpPromptContent, publishAcpPromptAttachments } from './prompt-content.js';
+import { AcpSessionMcp, createAcpMcpConfig } from './session-mcp.js';
 import { AcpSessionInteractions } from './session-interactions.js';
 const ACP_SESSION_CURSOR_MAX_BYTES = 8 * 1024;
 const ADMISSION_QUERY_MAX_ATTEMPTS = 5;
@@ -40,6 +41,8 @@ export class AcpSessionRegistry {
     #newTurnId;
     #inFlightOperations = new Set();
     #ownedSessionIds = new Set();
+    #mcps = new Map();
+    #creationAbort = new AbortController();
     #attachmentInteractions = new Map();
     #attachments = new Map();
     #attachmentOpenControllers = new Map();
@@ -58,10 +61,11 @@ export class AcpSessionRegistry {
         this.#newSessionId = options.newSessionId ?? randomUUID;
         this.#newTurnId = options.newTurnId ?? randomUUID;
     }
-    async create(params) {
+    async create(params, signal) {
         this.#assertOpen('session.create');
         validateNewSessionParams(params);
-        return this.#track(this.#create(params));
+        const mcpConfig = createAcpMcpConfig(params);
+        return this.#track(this.#create(params, mcpConfig, signal));
     }
     async list(params) {
         this.#assertOpen('session.catalog.query');
@@ -130,6 +134,7 @@ export class AcpSessionRegistry {
     dispose() {
         this.#closing = true;
         this.#connectAbortController?.abort();
+        this.#creationAbort.abort();
         this.#disposeTask ??= this.#dispose();
         return this.#disposeTask;
     }
@@ -214,6 +219,9 @@ export class AcpSessionRegistry {
                     throw error;
                 throw requestErrorFromRuntimeHost(error, 'artifact.ingest');
             }
+            if (active.cancelled)
+                return { stopReason: await this.#cancelledStopReason(active) };
+            await this.#mcps.get(params.sessionId)?.ready(active.projectionAbort.signal);
             if (active.cancelled)
                 return { stopReason: await this.#cancelledStopReason(active) };
             active.transcript = attachment.trackPromptTranscript(turnId);
@@ -591,8 +599,8 @@ export class AcpSessionRegistry {
             onInteractionPending: (pending) => {
                 if (!interactions.fencesTurn(pending.turnId) &&
                     ![...(this.#activePrompts.get(sessionId) ?? [])].some((active) => active.turnId === pending.turnId && active.dispatchStarted)) {
-                    // Idle attachments may observe a Turn started by another client. Do not
-                    // present its interaction through this ACP connection's client.
+                    // An idle attachment can observe another client's Turn; it does not
+                    // transfer that Turn's interaction authority to this ACP client.
                     return;
                 }
                 void interactions.pending(pending);
@@ -697,6 +705,14 @@ export class AcpSessionRegistry {
                 closeError = error;
             }
         }
+        const mcp = this.#mcps.get(sessionId);
+        this.#mcps.delete(sessionId);
+        try {
+            await mcp?.close();
+        }
+        catch (error) {
+            closeError ??= error;
+        }
         await delivery;
         const failedCancellation = cancellation.find((result) => result.status === 'rejected');
         if (failedCancellation)
@@ -745,11 +761,25 @@ export class AcpSessionRegistry {
         if (!this.#ownedSessionIds.has(sessionId))
             throw unknownSessionError();
     }
-    async #create(params) {
+    async #create(params, mcpConfig, signal) {
+        const lifetime = signal
+            ? AbortSignal.any([signal, this.#creationAbort.signal])
+            : this.#creationAbort.signal;
+        lifetime.throwIfAborted();
         const connection = await this.#getConnection('session.create');
         const sessionId = this.#newSessionId();
+        let mcp;
+        if (params.mcpServers.length > 0) {
+            mcp = new AcpSessionMcp(sessionId, mcpConfig, connection);
+            this.#mcps.set(sessionId, mcp);
+        }
         let result;
+        let dispatched = false;
         try {
+            await mcp?.prepare(lifetime);
+            lifetime.throwIfAborted();
+            this.#assertOpen('session.create');
+            dispatched = true;
             result = await connection.request('session.create', {
                 sessionId,
                 workspace: { kind: 'host_path', path: params.cwd },
@@ -757,6 +787,20 @@ export class AcpSessionRegistry {
             });
         }
         catch (error) {
+            const outcomeUnknown = dispatched &&
+                error instanceof RuntimeHostRequestInterruptedError &&
+                error.dispatch === 'dispatched';
+            if (outcomeUnknown && !this.#closing) {
+                // The error returns this ID. Keep its connection-local reservation usable
+                // without guessing whether Host committed or resending Session creation.
+                this.#ownedSessionIds.add(sessionId);
+            }
+            else {
+                this.#mcps.delete(sessionId);
+                await mcp?.close().catch(() => undefined);
+            }
+            if (error instanceof RequestError)
+                throw error;
             throw requestErrorFromRuntimeHost(error, 'session.create', { sessionId });
         }
         // Session creation has committed. Optional presentation failures must not
@@ -911,6 +955,9 @@ export class AcpSessionRegistry {
             }
         }
         await Promise.allSettled(cancellations);
+        const mcps = [...this.#mcps.values()];
+        this.#mcps.clear();
+        await Promise.allSettled(mcps.map((mcp) => mcp.close()));
         await Promise.allSettled([this.#closeOwnedConnection()]);
         await Promise.allSettled([
             ...this.#inFlightOperations,
@@ -995,9 +1042,6 @@ function registryClosedError(operation) {
 }
 function validateNewSessionParams(params) {
     assertBoundedAbsoluteCwd(params.cwd);
-    if (params.mcpServers.length > 0) {
-        throw RequestError.invalidParams({ field: 'mcpServers', reason: 'unsupported' }, 'MCP servers are not supported by this ACP adapter yet');
-    }
     if ((params.additionalDirectories?.length ?? 0) > 0) {
         throw RequestError.invalidParams({ field: 'additionalDirectories', reason: 'unsupported' }, 'Additional directories are not supported by this ACP adapter yet');
     }

package/dist/acp/stdio-server.js

@@ -40,6 +40,9 @@ export async function runMakaAcpStdioServer(input, dependencies = {}) {
                 request: connection.request.bind(connection),
                 openSessionSubscription: connection.openSessionSubscription.bind(connection),
                 openSessionSubscriptionOnce: connection.openSessionSubscriptionOnce.bind(connection),
+                replaceClientCapabilities: (provider, options) => connection.replaceClientCapabilities(provider, options),
+                unregisterClientCapabilities: (options) => connection.unregisterClientCapabilities(options),
+                subscribeConnectionAvailability: (listener) => connection.subscribeConnectionAvailability(listener),
                 close: () => context.close(),
             };
         },

package/dist/cli-core.js

@@ -101,7 +101,7 @@ function helpText(cliCommand) {
         'Commands:',
         ...[
             ['', 'Start the TUI'],
-            ['--acp', 'Serve ACP v1 over stdio (sessions, prompts, streaming, cancellation)'],
+            ['--acp', 'Serve ACP v1 over stdio (sessions, tools, permissions, forms, stdio MCP)'],
             ['run ...', 'Run one non-interactive model turn'],
             ['-p ...', `Alias for ${cliCommand} run`],
             ['activate ...', 'Run one Cloud Session activation and emit JSONL'],

package/dist/mcp-capability-provider.js

@@ -20,7 +20,7 @@ import { createHash } from 'node:crypto';
 import { clientCapabilityEntityId } from '@maka/runtime-host/client-capability-entity-id';
 import { CLIENT_CAPABILITY_MAX_TOOLS, CLIENT_CAPABILITY_MAX_TOOLS_PER_OFFER, decodeClientCapabilityReplaceInput, } from '@maka/runtime-host/protocol';
 const CAPABILITY_VERSION = '0';
-export function createMcpCapabilityProvider(manager) {
+export function createMcpCapabilityProvider(manager, options = {}) {
     const toolSnapshot = manager.toolSnapshot();
     const tools = [...toolSnapshot.tools].sort((left, right) => left.descriptor.serverId.localeCompare(right.descriptor.serverId) ||
         left.descriptor.name.localeCompare(right.descriptor.name));
@@ -52,6 +52,7 @@ export function createMcpCapabilityProvider(manager) {
             version: CAPABILITY_VERSION,
             affinity: 'session',
             hostPathAccess: 'none',
+            ...(options.admission ? { admission: options.admission } : {}),
             label: servers.size === 1
                 ? `MCP: ${chunk[0]?.source.descriptor.serverId ?? 'tools'}`.slice(0, 128)
                 : `MCP tools (${servers.size} servers)`,
@@ -64,10 +65,14 @@ export function createMcpCapabilityProvider(manager) {
     }
     const canonical = decodeClientCapabilityReplaceInput({
         registrationId: '00000000-0000-4000-8000-000000000000',
+        ...(options.admission ? { sessionId: 'mcp-manifest-validation' } : {}),
         offers,
     });
     return {
         offers: () => canonical.offers,
+        ...(options.onCurrentRegistrationRetired
+            ? { currentRegistrationRetired: options.onCurrentRegistrationRetired }
+            : {}),
         call: async (frame, options) => {
             const binding = bindings.get(capabilityBindingKey(frame.offerId, frame.serverId, frame.toolName));
             if (!binding)

package/dist/mcp-capability-publication.js

@@ -0,0 +1,139 @@
+/*
+ * 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.
+ */
+/** Coalesces MCP snapshots and never commits a publication from an obsolete connection. */
+export class McpCapabilityPublication {
+    #options;
+    #requested = false;
+    #task;
+    #closeTask;
+    #closed = false;
+    #state = 'unavailable';
+    #published;
+    constructor(options) {
+        this.#options = options;
+    }
+    invalidate() {
+        this.#published = undefined;
+    }
+    request() {
+        if (this.#closed)
+            return;
+        this.#requested = true;
+        if (this.#task)
+            return;
+        this.#task = this.#run().finally(() => {
+            this.#task = undefined;
+            if (this.#requested && !this.#closed)
+                this.request();
+        });
+    }
+    async settle() {
+        this.request();
+        while (this.#task)
+            await this.#task;
+        return this.#closed ? 'unavailable' : this.#state;
+    }
+    close() {
+        this.#closeTask ??= this.#close(true);
+        return this.#closeTask;
+    }
+    /** Stops local publication state after the Host has already retired its current registration. */
+    retire() {
+        this.#closeTask ??= this.#close(false);
+        return this.#closeTask;
+    }
+    async #close(unregister) {
+        this.#closed = true;
+        this.#requested = false;
+        await this.#task;
+        try {
+            if (unregister &&
+                this.#published?.registered &&
+                this.#published.identity === this.#options.connectionIdentity()) {
+                await this.#options.unregister();
+            }
+        }
+        finally {
+            this.#published = undefined;
+        }
+    }
+    async #run() {
+        while (this.#requested && !this.#closed) {
+            this.#requested = false;
+            await this.#publish();
+        }
+    }
+    async #publish() {
+        const identity = this.#options.connectionIdentity();
+        if (identity === undefined) {
+            this.#setState('unavailable');
+            return;
+        }
+        const revision = this.#options.revision();
+        if (this.#published?.identity === identity && this.#published.revision === revision) {
+            this.#setState(this.#published.registered ? 'published' : 'not_published');
+            return;
+        }
+        let provider;
+        this.#setState('publishing');
+        try {
+            provider = this.#options.createProvider();
+            if (provider)
+                await this.#options.replace(provider);
+            else if (this.#published?.identity === identity && this.#published.registered) {
+                await this.#options.unregister();
+            }
+        }
+        catch {
+            try {
+                await provider?.close?.();
+            }
+            catch {
+                /* Rejected provider cleanup is best effort. */
+            }
+            if (this.#isCurrent(identity, revision))
+                this.#setState('error');
+            else if (!this.#closed)
+                this.#requested = true;
+            return;
+        }
+        // Even an obsolete snapshot may have committed on the current connection.
+        // Retain that fact so an empty replacement or close can unregister it.
+        if (this.#options.connectionIdentity() === identity) {
+            this.#published = { identity, revision, registered: provider !== undefined };
+        }
+        if (!this.#isCurrent(identity, revision)) {
+            if (!this.#closed)
+                this.#requested = true;
+            return;
+        }
+        this.#setState(provider ? 'published' : 'not_published');
+    }
+    #isCurrent(identity, revision) {
+        return (!this.#closed &&
+            this.#options.connectionIdentity() === identity &&
+            this.#options.revision() === revision);
+    }
+    #setState(state) {
+        if (this.#closed)
+            return;
+        this.#state = state;
+        this.#options.onState(state);
+    }
+}