maka-agent 0.2.0-dev.49.20260924 → 0.2.0-dev.50.20260925

package/LICENSE

@@ -574,6 +574,41 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 
+virtua dependency patch
+
+Source: https://www.npmjs.com/package/virtua/v/0.52.7
+Repository: https://github.com/inokawa/virtua
+Version: 0.52.7
+Dependency patch: patches/virtua+0.52.7.patch
+Copyright (c) 2022 inokawa
+License: MIT
+
+Maka redistributes a source patch that applies virtua's scroll correction
+absolutely after the browser clamps the scroll offset. The following MIT
+License applies to that material:
+
+MIT License
+
+Copyright (c) 2022 inokawa
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
 trycua/cua cursor-overlay
 
 Source: https://github.com/trycua/cua

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

@@ -16,7 +16,8 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { agent, methods } from '@agentclientprotocol/sdk';
+import { agent, methods, RequestError, } from '@agentclientprotocol/sdk';
+import { HOST_OPERATION_SPECS } from '@maka/runtime-host/protocol';
 export function createMakaAcpAgent(options) {
     let clientCapabilities = {};
     return agent({ name: 'maka' })
@@ -24,25 +25,84 @@ export function createMakaAcpAgent(options) {
         clientCapabilities = structuredClone(params.clientCapabilities ?? {});
         return {
             protocolVersion: 1,
-            agentCapabilities: { sessionCapabilities: { list: {}, close: {} } },
+            agentCapabilities: {
+                loadSession: true,
+                sessionCapabilities: { list: {}, resume: {}, close: {} },
+            },
             authMethods: [],
             agentInfo: { name: 'maka', title: 'Maka', version: options.version },
         };
     })
         .onRequest(methods.agent.session.new, ({ params, signal }) => options.sessionRegistry.create(params, signal))
+        .onRequest(methods.agent.session.load, ({ params, signal, client }) => options.sessionRegistry.load(params, sessionContext(client, signal, clientCapabilities, true)))
+        .onRequest(methods.agent.session.resume, ({ params, signal, client }) => options.sessionRegistry.resume(params, sessionContext(client, signal, clientCapabilities, true)))
+        .onRequest('_maka/turn/resume', (value) => {
+        try {
+            return HOST_OPERATION_SPECS['turn.resume.query'].decodeInput(value);
+        }
+        catch {
+            throw RequestError.invalidParams({ reason: 'invalid_resume_query' }, 'Invalid Turn resume request');
+        }
+    }, ({ params, signal, client }) => options.sessionRegistry.resumeTurn(params, sessionContext(client, signal, clientCapabilities, true)))
+        .onRequest('_maka/session/copy-source/query', {
+        parse: (value) => {
+            try {
+                return HOST_OPERATION_SPECS['session.turns.query'].decodeInput(value);
+            }
+            catch {
+                throw RequestError.invalidParams({ reason: 'invalid_copy_source_query' }, 'Invalid Session copy source query');
+            }
+        },
+    }, ({ params }) => options.sessionRegistry.queryCopySource(params))
+        .onRequest('_maka/session/branch/create', {
+        parse: (value) => {
+            try {
+                return HOST_OPERATION_SPECS['session.branch.create'].decodeInput(value);
+            }
+            catch {
+                throw RequestError.invalidParams({ reason: 'invalid_branch_input' }, 'Invalid Session branch request');
+            }
+        },
+    }, ({ params }) => options.sessionRegistry.branch(params))
+        .onRequest('_maka/session/revision/create', {
+        parse: (value) => {
+            try {
+                return HOST_OPERATION_SPECS['session.revision.create'].decodeInput(value);
+            }
+            catch {
+                throw RequestError.invalidParams({ reason: 'invalid_revision_input' }, 'Invalid Session revision request');
+            }
+        },
+    }, ({ params }) => options.sessionRegistry.createRevision(params))
+        .onRequest('_maka/session/revision/abandon', {
+        parse: (value) => {
+            try {
+                return HOST_OPERATION_SPECS['session.revision.abandon'].decodeInput(value);
+            }
+            catch {
+                throw RequestError.invalidParams({ reason: 'invalid_abandon_input' }, 'Invalid Session abandon request');
+            }
+        },
+    }, ({ params }) => options.sessionRegistry.abandonRevision(params))
         .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, {
+        .onRequest(methods.agent.session.prompt, ({ params, signal, client }) => options.sessionRegistry.prompt(params, sessionContext(client, signal, clientCapabilities)))
+        .onNotification(methods.agent.session.cancel, ({ params }) => options.sessionRegistry.cancel(params))
+        .onRequest(methods.agent.session.close, ({ params }) => options.sessionRegistry.close(params));
+}
+function sessionContext(client, signal, capabilities, turnStatus = false) {
+    return {
         signal,
         notify: (notification) => client.notify(methods.client.session.update, notification),
         interactions: {
-            capabilities: clientCapabilities,
-            requestPermission: (params, cancellationSignal) => client.request(methods.client.session.requestPermission, params, {
-                cancellationSignal,
-            }),
-            createElicitation: (params, cancellationSignal) => client.request(methods.client.elicitation.create, params, { cancellationSignal }),
+            capabilities,
+            requestPermission: (request, cancellationSignal) => client.request(methods.client.session.requestPermission, request, { cancellationSignal }),
+            createElicitation: (request, cancellationSignal) => client.request(methods.client.elicitation.create, request, { cancellationSignal }),
         },
-    }))
-        .onNotification(methods.agent.session.cancel, ({ params }) => options.sessionRegistry.cancel(params))
-        .onRequest(methods.agent.session.close, ({ params }) => options.sessionRegistry.close(params));
+        ...(turnStatus && capabilities._meta?.['_maka/turnStatus'] === true
+            ? {
+                notifyTurnStatus: (status) => client.notify('_maka/turn/status', status),
+            }
+            : {}),
+    };
 }

package/dist/acp/session-event-mapper.js

@@ -18,6 +18,7 @@
  */
 import { foldRuntimeHostAssistantDelta } from '@maka/runtime-host/adapter';
 import { RequestError, } from '@agentclientprotocol/sdk';
+import { userFacingText } from '@maka/core/session';
 import { whileActive } from './active-promise.js';
 import { AcpToolEventMapper } from './tool-event-mapper.js';
 /** Serializes one ACP prompt's live projection delivery. */
@@ -67,20 +68,72 @@ export class AcpSessionEventMapper {
         return this.acceptTranscriptMessages(turnId, messages);
     }
     /** Apply a bounded authoritative batch; absence from one batch never removes a tool. */
-    acceptTranscriptMessages(turnId, messages) {
+    acceptTranscriptMessages(turnId, messages, ignoreOlder = false) {
         return this.#enqueue(async () => {
             for (const message of messages) {
                 if (message.turnId !== turnId)
                     continue;
                 if (message.type === 'assistant') {
-                    await this.#acceptText('thinking', message.id, message.thinking?.text ?? '');
-                    await this.#acceptText('text', message.id, message.text);
+                    const thinking = message.thinking?.text ?? '';
+                    if (!ignoreOlder ||
+                        thinking.startsWith(this.#streams.get(streamKey('thinking', message.id)) ?? ''))
+                        await this.#acceptText('thinking', message.id, thinking);
+                    if (!ignoreOlder ||
+                        message.text.startsWith(this.#streams.get(streamKey('text', message.id)) ?? ''))
+                        await this.#acceptText('text', message.id, message.text);
                 }
                 else
                     await this.#tools.acceptMessage(message);
             }
         });
     }
+    /** Replay one durable row in transcript order for session/load. */
+    acceptHistoricalMessage(message) {
+        return this.#enqueue(async () => {
+            if (message.type === 'user') {
+                // ACP v1 has no mid-Turn steering update. Live projection omits these
+                // rows, so historical replay must not present them as new user turns.
+                if (message.steeringEventId)
+                    return;
+                const attachments = message.attachments ?? [];
+                const text = [
+                    userFacingText(message),
+                    ...attachments.map((attachment) => `[Attachment: ${attachment.name} (${attachment.mimeType}, ${attachment.bytes} bytes)]`),
+                ]
+                    .filter(Boolean)
+                    .join('\n\n');
+                if (text) {
+                    await this.#deliver({
+                        sessionId: this.#sessionId,
+                        update: {
+                            sessionUpdate: 'user_message_chunk',
+                            content: { type: 'text', text },
+                            messageId: message.id,
+                            ...(attachments.length || message.origin
+                                ? {
+                                    _meta: {
+                                        ...(attachments.length
+                                            ? { '_maka/attachments': structuredClone(attachments) }
+                                            : {}),
+                                        ...(message.origin
+                                            ? { '_maka/origin': structuredClone(message.origin) }
+                                            : {}),
+                                    },
+                                }
+                                : {}),
+                        },
+                    });
+                }
+            }
+            else if (message.type === 'assistant') {
+                await this.#acceptText('thinking', message.id, message.thinking?.text ?? '');
+                await this.#acceptText('text', message.id, message.text);
+            }
+            else {
+                await this.#tools.acceptMessage(message);
+            }
+        });
+    }
     finishTools(turnId, terminalStatus = 'completed') {
         return this.#enqueue(() => this.#tools.finishTools(turnId, terminalStatus));
     }
@@ -97,6 +150,9 @@ export class AcpSessionEventMapper {
                 throw this.#failure;
         });
     }
+    textForMessage(kind, messageId) {
+        return this.#streams.get(streamKey(kind, messageId));
+    }
     async #acceptText(kind, hostMessageId, nextText) {
         const key = streamKey(kind, hostMessageId);
         const current = this.#streams.get(key) ?? '';

package/dist/acp/session-interactions.js

@@ -33,6 +33,8 @@ function questionAnswerMaxChars(count) {
 /** Connection-local presentation of Host interactions; the Host owns every answer and grant. */
 export class AcpSessionInteractions {
     #options;
+    #client;
+    #clientLease;
     #lifetime = new AbortController();
     #pending = new Map();
     #resolving = new Map();
@@ -41,6 +43,34 @@ export class AcpSessionInteractions {
     #cancelledInteractions = new Set();
     constructor(options) {
         this.#options = options;
+        this.#client = options.client;
+        this.#clientLease = { client: options.client, valid: true };
+    }
+    setClient(client) {
+        const lease = {
+            client,
+            previous: this.#clientLease,
+            valid: true,
+        };
+        this.#clientLease = lease;
+        this.#client = client;
+        return {
+            rollback: () => {
+                lease.valid = false;
+                if (this.#clientLease !== lease)
+                    return;
+                let previous = lease.previous;
+                while (previous && !previous.valid)
+                    previous = previous.previous;
+                if (!previous)
+                    return;
+                this.#clientLease = previous;
+                this.#client = previous.client;
+            },
+            commit: () => {
+                lease.previous = undefined;
+            },
+        };
     }
     pending(snapshot) {
         if (this.#lifetime.signal.aborted) {
@@ -159,7 +189,7 @@ export class AcpSessionInteractions {
         }
         const request = pending.request;
         if ((request.kind === 'question' || request.kind === 'form') &&
-            this.#options.client.capabilities.elicitation?.form == null) {
+            this.#client.capabilities.elicitation?.form == null) {
             throw interactionError(pending, 'unsupported_interaction', 'Client requires form elicitation');
         }
         const presented = await whileActive(Promise.resolve().then(() => {
@@ -170,7 +200,7 @@ export class AcpSessionInteractions {
             return;
         let answer;
         if (request.kind === 'question' || request.kind === 'form') {
-            const response = await whileActive(this.#options.client.createElicitation(elicitationRequest(pending), signal), signal);
+            const response = await whileActive(this.#client.createElicitation(elicitationRequest(pending), signal), signal);
             if (!response.active)
                 return;
             if (request.kind === 'question' && response.value.action === 'cancel') {
@@ -188,7 +218,7 @@ export class AcpSessionInteractions {
         }
         else {
             const presentation = permissionPresentation(pending);
-            const response = await whileActive(this.#options.client.requestPermission(presentation.request, signal), signal);
+            const response = await whileActive(this.#client.requestPermission(presentation.request, signal), signal);
             if (!response.active)
                 return;
             if (response.value.outcome.outcome === 'cancelled') {

package/dist/acp/session-mcp.js

@@ -16,12 +16,14 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+import { createHash } from 'node:crypto';
 import { isAbsolute } from 'node:path';
 import { RequestError } from '@agentclientprotocol/sdk';
 import { MCP_CONFIG_VERSION } from '@maka/core/mcp';
+import { stableJsonStringify } from '@maka/core/canonical-json';
 import { McpClientManager } from '@maka/mcp';
 import { normalizeMcpConfig } from '@maka/storage/mcp-config-store';
-import { abortable } from '@maka/runtime-host/client';
+import { RuntimeHostOperationError, 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. */
@@ -80,6 +82,7 @@ export function createAcpMcpConfig(params) {
 export class AcpSessionMcp {
     #sessionId;
     #config;
+    #configurationTail = Promise.resolve();
     #manager = new McpClientManager({
         clientName: 'maka-acp',
         excludedStdioEnvironmentKeys: ['MAKA_RUNTIME_HOST_ACCESS_CREDENTIAL'],
@@ -87,6 +90,11 @@ export class AcpSessionMcp {
     #publication;
     #unsubscribeManager;
     #unsubscribeConnection;
+    #pendingManager;
+    #retainedManagers = new Set();
+    #retirementTasks = new Set();
+    #publicationRevision = 0;
+    #requireIdlePublication = false;
     #availability;
     #prepared = false;
     #closed = false;
@@ -99,7 +107,7 @@ export class AcpSessionMcp {
             connectionIdentity: () => this.#availability?.kind === 'connected'
                 ? this.#availability.hostEpoch + '\0' + this.#availability.connectionId
                 : undefined,
-            revision: () => this.#manager.toolSnapshot().revision,
+            revision: () => this.#publicationRevision,
             createProvider: () => createMcpCapabilityProvider(this.#manager, {
                 admission: 'mcp',
                 onCurrentRegistrationRetired: () => this.#retire(),
@@ -110,14 +118,21 @@ export class AcpSessionMcp {
                 offers: () => [],
                 currentRegistrationRetired: () => this.#retire(),
             },
-            replace: (provider) => connection.replaceClientCapabilities(provider, { sessionId }),
+            replace: (provider) => connection.replaceClientCapabilities(provider, {
+                sessionId,
+                sessionConfigurationId: `sha256:${createHash('sha256').update(stableJsonStringify(this.#config)).digest('hex')}`,
+                ...(this.#requireIdlePublication ? { requireIdleSession: true } : {}),
+            }),
             unregister: () => connection.unregisterClientCapabilities({ sessionId }),
-            onState: () => undefined,
-        });
-        this.#unsubscribeManager = this.#manager.onChange(() => {
-            if (this.#prepared && !this.#closed)
-                this.#publication.request();
+            onState: (state) => {
+                if ((state === 'published' || state === 'not_published') &&
+                    this.#publication.publishedRevision === this.#publicationRevision) {
+                    this.#requireIdlePublication = false;
+                    this.#retireRetainedManagers();
+                }
+            },
         });
+        this.#unsubscribeManager = this.#observeManager(this.#manager);
         this.#unsubscribeConnection = connection.subscribeConnectionAvailability((availability) => {
             this.#availability = availability;
             if (availability.kind !== 'connected')
@@ -150,13 +165,118 @@ export class AcpSessionMcp {
             signal?.removeEventListener('abort', cancel);
         }
     }
+    get config() {
+        return structuredClone(this.#config);
+    }
+    reconfigure(config, signal, assertCanChange) {
+        const task = this.#configurationTail
+            .catch(() => undefined)
+            .then(async () => {
+            this.#assertOpen('mcp.prepare');
+            signal?.throwIfAborted();
+            if (sameMcpConfig(this.#config, config))
+                return this.#settlePublication(signal);
+            if (this.#retainedManagers.size > 0)
+                await this.#settlePublication(signal);
+            await assertCanChange?.();
+            signal?.throwIfAborted();
+            const previous = this.#manager;
+            const previousConfig = this.#config;
+            const staged = new McpClientManager({
+                clientName: 'maka-acp',
+                excludedStdioEnvironmentKeys: ['MAKA_RUNTIME_HOST_ACCESS_CREDENTIAL'],
+            });
+            this.#pendingManager = staged;
+            let swapped = false;
+            let previousRevision = this.#publicationRevision;
+            try {
+                await staged.sync(config);
+                signal?.throwIfAborted();
+                this.#assertConnected(config, staged);
+                previousRevision = this.#publicationRevision;
+                this.#unsubscribeManager();
+                this.#manager = staged;
+                this.#config = config;
+                this.#unsubscribeManager = this.#observeManager(staged);
+                this.#retainedManagers.add(previous);
+                this.#pendingManager = undefined;
+                swapped = true;
+                this.#requireIdlePublication = true;
+                this.#publicationRevision += 1;
+                this.#publication.request();
+                await this.#settlePublication(signal);
+                this.#requireIdlePublication = false;
+                this.#retireRetainedManagers();
+                await Promise.allSettled([...this.#retirementTasks]);
+            }
+            catch (error) {
+                if (swapped && !this.#closed) {
+                    // Cancellation can win after the Host committed a new provider but
+                    // before its response arrived. Resolve the in-flight publication
+                    // before deciding which manager may be released.
+                    await this.#publication.waitForPending();
+                    if (this.#publication.publishedRevision === previousRevision &&
+                        this.#publication.lastError instanceof RuntimeHostOperationError) {
+                        this.#unsubscribeManager();
+                        this.#manager = previous;
+                        this.#config = previousConfig;
+                        this.#unsubscribeManager = this.#observeManager(previous);
+                        this.#retainedManagers.delete(previous);
+                        this.#publicationRevision = previousRevision;
+                        this.#requireIdlePublication = false;
+                        this.#publication.request();
+                        await this.#publication.settle().catch(() => undefined);
+                        await staged.close().catch(() => undefined);
+                    }
+                    else {
+                        // A committed or unknown outcome may already be serving a Turn.
+                        // Keep that provider and its manager; the previous manager stays
+                        // available until a definitive publication or Session close.
+                        this.#retireRetainedManagers();
+                    }
+                }
+                else if (!swapped) {
+                    this.#pendingManager = undefined;
+                    await staged.close().catch(() => undefined);
+                }
+                if (error instanceof RequestError)
+                    throw error;
+                throw mcpUnavailable(this.#sessionId, 'mcp.prepare', 'mcp_reconfiguration_failed');
+            }
+        });
+        this.#configurationTail = task;
+        return task;
+    }
     async ready(signal) {
+        await abortable(() => this.#configurationTail.catch(() => undefined), signal);
+        await this.#settlePublication(signal);
+    }
+    async #settlePublication(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') {
+            if (this.#publication.lastError instanceof RuntimeHostOperationError &&
+                this.#publication.lastError.code === 'session_binding_conflict') {
+                throw RequestError.internalError({
+                    source: 'runtime_host',
+                    operation: 'mcp.prepare',
+                    sessionId: this.#sessionId,
+                    code: 'session_binding_conflict',
+                }, 'Session MCP configuration conflicts with an active or frozen provider; restore with the same configuration or close the active attachment');
+            }
+            if (this.#requireIdlePublication &&
+                this.#publication.lastError instanceof RuntimeHostOperationError &&
+                this.#publication.lastError.code === 'session_busy') {
+                throw RequestError.internalError({
+                    source: 'runtime_host',
+                    operation: 'mcp.prepare',
+                    sessionId: this.#sessionId,
+                    code: 'session_busy',
+                }, 'Cannot replace Session MCP configuration during an active Turn');
+            }
             throw mcpUnavailable(this.#sessionId, 'mcp.ready', 'mcp_publication_failed');
         }
     }
@@ -173,7 +293,12 @@ export class AcpSessionMcp {
         this.#closed = true;
         this.#unsubscribeManager();
         this.#unsubscribeConnection();
-        const managerClose = this.#manager.close();
+        const managerClose = Promise.allSettled([
+            this.#manager.close(),
+            this.#pendingManager?.close(),
+            ...[...this.#retainedManagers].map((manager) => manager.close()),
+            ...this.#retirementTasks,
+        ]);
         this.#closeTask = (async () => {
             try {
                 try {
@@ -193,9 +318,30 @@ export class AcpSessionMcp {
         })();
         return this.#closeTask;
     }
-    #assertConnected() {
+    #observeManager(manager) {
+        return manager.onChange(() => {
+            this.#publicationRevision += 1;
+            if (this.#prepared && !this.#closed)
+                this.#publication.request();
+        });
+    }
+    #retireRetainedManagers() {
+        if (this.#publication.publishedRevision !== this.#publicationRevision)
+            return;
+        for (const manager of this.#retainedManagers) {
+            this.#retainedManagers.delete(manager);
+            if (manager === this.#manager)
+                continue;
+            const task = manager.close().catch((error) => {
+                console.error('[acp] Previous Session MCP cleanup failed:', error);
+            });
+            this.#retirementTasks.add(task);
+            void task.finally(() => this.#retirementTasks.delete(task));
+        }
+    }
+    #assertConnected(config = this.#config, manager = this.#manager) {
         this.#assertOpen('mcp.prepare');
-        if (Object.keys(this.#config.mcpServers).some((serverId) => this.#manager.status(serverId)?.state !== 'connected')) {
+        if (Object.keys(config.mcpServers).some((serverId) => manager.status(serverId)?.state !== 'connected')) {
             throw mcpUnavailable(this.#sessionId, 'mcp.prepare', 'mcp_not_ready');
         }
     }
@@ -204,6 +350,9 @@ export class AcpSessionMcp {
             throw mcpUnavailable(this.#sessionId, operation, 'mcp_not_ready');
     }
 }
+function sameMcpConfig(left, right) {
+    return stableJsonStringify(left) === stableJsonStringify(right);
+}
 function invalidMcpInput(reason) {
     return RequestError.invalidParams({ field: 'mcpServers', reason }, 'Invalid ACP stdio MCP configuration');
 }