maka-agent 0.2.0-dev.51.20260925 → 0.2.0-dev.52.20260926

package/dist/acp/goal-plan-operations.js

@@ -0,0 +1,142 @@
+/*
+ * 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 { RequestError } from '@agentclientprotocol/sdk';
+import { RuntimeHostOperationError, RuntimeHostRequestInterruptedError, } from '@maka/runtime-host/client';
+export class AcpGoalPlanOperations {
+    #port;
+    constructor(port) {
+        this.#port = port;
+    }
+    goalQuery(input, context) {
+        return this.#run('goal.query', input, context, !!context.notifyGoalStatus);
+    }
+    goalArm(input, context) {
+        return this.#run('goal.arm', input, context, true);
+    }
+    goalControl(input, context) {
+        return this.#run('goal.control', input, context, true);
+    }
+    planQuery(input, context) {
+        return this.#run('plan.query', input, context, !!context.notifyPlanChanged);
+    }
+    planControl(input, context) {
+        return this.#run('plan.control', input, context, true);
+    }
+    async planTurnStart(input, context) {
+        const prepared = await this.#port.prepare(input.sessionId, context, input.turnId, true);
+        let dispatched = false;
+        const onAbort = () => prepared.cancelObservation?.();
+        context.signal.addEventListener('abort', onAbort, { once: true });
+        if (context.signal.aborted)
+            onAbort();
+        try {
+            context.signal.throwIfAborted();
+            this.#port.assertCurrent(input.sessionId);
+            const observation = prepared.observation;
+            if (!observation && !prepared.observedReplay)
+                throw new Error('Plan Turn observer was not installed');
+            observation?.markDispatched();
+            dispatched = true;
+            const result = await prepared.connection.request('plan.turn.start', input);
+            observation?.settleStartRequest(result.turn);
+            prepared.commit();
+            return result;
+        }
+        catch (error) {
+            if (dispatched && isDispatchedUnknown(error)) {
+                prepared.observation?.failStartRequest(error);
+                prepared.reconcileAdmission?.();
+                prepared.commit();
+                throw RequestError.internalError({
+                    source: 'runtime_host',
+                    operation: 'plan.turn.start',
+                    code: 'outcome_unknown',
+                    dispatch: 'dispatched',
+                    sessionId: input.sessionId,
+                    turnId: input.turnId,
+                    ...(input.kind === 'approve_proposal'
+                        ? { proposalId: input.proposalId }
+                        : { executionId: input.executionId }),
+                }, 'Plan Turn start outcome is unknown; query the Plan and exact Turn before retrying');
+            }
+            if (dispatched && isPersistenceUnknown(error)) {
+                prepared.observation?.failStartRequest(error);
+                prepared.reconcileAdmission?.();
+                prepared.commit();
+                throw this.#port.mapError(error, 'plan.turn.start', {
+                    sessionId: input.sessionId,
+                    turnId: input.turnId,
+                });
+            }
+            prepared.rollback(error);
+            if (error instanceof RequestError)
+                throw error;
+            throw this.#port.mapError(error, 'plan.turn.start', {
+                sessionId: input.sessionId,
+                turnId: input.turnId,
+            });
+        }
+        finally {
+            context.signal.removeEventListener('abort', onAbort);
+        }
+    }
+    async #run(operation, input, context, observe) {
+        const prepared = await this.#port.prepare(input.sessionId, context, undefined, observe);
+        let dispatched = false;
+        try {
+            context.signal.throwIfAborted();
+            this.#port.assertCurrent(input.sessionId);
+            dispatched = true;
+            // The Host protocol validates both request and response against the operation spec.
+            const result = await prepared.connection.request(operation, input);
+            prepared.commit();
+            return result;
+        }
+        catch (error) {
+            if (dispatched && isDispatchedUnknown(error)) {
+                prepared.commit();
+                throw RequestError.internalError({
+                    source: 'runtime_host',
+                    operation,
+                    code: 'outcome_unknown',
+                    dispatch: 'dispatched',
+                    sessionId: input.sessionId,
+                    ...('goalId' in input ? { goalId: input.goalId } : {}),
+                    ...('operationId' in input ? { operationId: input.operationId } : {}),
+                    ...('proposalId' in input ? { proposalId: input.proposalId } : {}),
+                    ...('executionId' in input ? { executionId: input.executionId } : {}),
+                }, 'Runtime Host operation outcome is unknown; query authoritative state before retrying');
+            }
+            if (dispatched && isPersistenceUnknown(error)) {
+                prepared.commit();
+                throw this.#port.mapError(error, operation, { sessionId: input.sessionId });
+            }
+            prepared.rollback(error);
+            if (error instanceof RequestError)
+                throw error;
+            throw this.#port.mapError(error, operation, { sessionId: input.sessionId });
+        }
+    }
+}
+function isDispatchedUnknown(error) {
+    return error instanceof RuntimeHostRequestInterruptedError && error.dispatch === 'dispatched';
+}
+function isPersistenceUnknown(error) {
+    return error instanceof RuntimeHostOperationError && error.code === 'persistence_failed';
+}

package/dist/acp/goal-plan-routes.js

@@ -0,0 +1,33 @@
+/*
+ * 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 { RequestError } from '@agentclientprotocol/sdk';
+import { HOST_OPERATION_SPECS } from '@maka/runtime-host/protocol';
+/** Keep ACP extension parsing identical to the Host's current wire contract. */
+export function goalPlanRouteInput(operation) {
+    return {
+        parse(value) {
+            try {
+                return HOST_OPERATION_SPECS[operation].decodeInput(value);
+            }
+            catch {
+                throw RequestError.invalidParams({ reason: 'invalid_goal_plan_input', operation }, `Invalid ${operation} request`);
+            }
+        },
+    };
+}

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

@@ -18,6 +18,7 @@
  */
 import { agent, methods, RequestError, } from '@agentclientprotocol/sdk';
 import { HOST_OPERATION_SPECS } from '@maka/runtime-host/protocol';
+import { goalPlanRouteInput } from './goal-plan-routes.js';
 export function createMakaAcpAgent(options) {
     let clientCapabilities = {};
     return agent({ name: 'maka' })
@@ -28,6 +29,7 @@ export function createMakaAcpAgent(options) {
             agentCapabilities: {
                 loadSession: true,
                 sessionCapabilities: { list: {}, resume: {}, close: {} },
+                _meta: { '_maka/goalPlan': { version: 1 } },
             },
             authMethods: [],
             agentInfo: { name: 'maka', title: 'Maka', version: options.version },
@@ -44,6 +46,12 @@ export function createMakaAcpAgent(options) {
             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/goal/query', goalPlanRouteInput('goal.query'), ({ params, signal, client }) => options.sessionRegistry.goalQuery(params, sessionContext(client, signal, clientCapabilities, true)))
+        .onRequest('_maka/goal/arm', goalPlanRouteInput('goal.arm'), ({ params, signal, client }) => options.sessionRegistry.goalArm(params, sessionContext(client, signal, clientCapabilities, true)))
+        .onRequest('_maka/goal/control', goalPlanRouteInput('goal.control'), ({ params, signal, client }) => options.sessionRegistry.goalControl(params, sessionContext(client, signal, clientCapabilities, true)))
+        .onRequest('_maka/plan/query', goalPlanRouteInput('plan.query'), ({ params, signal, client }) => options.sessionRegistry.planQuery(params, sessionContext(client, signal, clientCapabilities, true)))
+        .onRequest('_maka/plan/control', goalPlanRouteInput('plan.control'), ({ params, signal, client }) => options.sessionRegistry.planControl(params, sessionContext(client, signal, clientCapabilities, true)))
+        .onRequest('_maka/plan/turn/start', goalPlanRouteInput('plan.turn.start'), ({ params, signal, client }) => options.sessionRegistry.planTurnStart(params, sessionContext(client, signal, clientCapabilities, true)))
         .onRequest('_maka/session/copy-source/query', {
         parse: (value) => {
             try {
@@ -88,7 +96,33 @@ export function createMakaAcpAgent(options) {
         .onRequest(methods.agent.session.setConfigOption, ({ params }) => options.sessionRegistry.setConfigOption(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));
+        .onRequest(methods.agent.session.close, ({ params }) => options.sessionRegistry.close(params))
+        .onRequest('_maka/artifact/query', extensionParams('artifact.query', HOST_OPERATION_SPECS['artifact.query'].decodeInput), ({ params }) => options.sessionRegistry.artifactQuery(params))
+        .onRequest('_maka/artifact/ingest', extensionParams('artifact.ingest', HOST_OPERATION_SPECS['artifact.ingest'].decodeInput), ({ params }) => options.sessionRegistry.artifactIngest(params))
+        .onRequest('_maka/artifact/delete', extensionParams('artifact.delete', HOST_OPERATION_SPECS['artifact.delete'].decodeInput), ({ params }) => options.sessionRegistry.artifactDelete(params))
+        .onRequest('_maka/memory/query', extensionParams('memory.query', HOST_OPERATION_SPECS['memory.query'].decodeInput), ({ params }) => options.sessionRegistry.memoryQuery(params))
+        .onRequest('_maka/memory/mutate', extensionParams('memory.mutate', HOST_OPERATION_SPECS['memory.mutate'].decodeInput), ({ params }) => options.sessionRegistry.memoryMutate(params));
+}
+function extensionParams(operation, decode) {
+    return (params) => {
+        try {
+            if (params && typeof params === 'object' && !Array.isArray(params) && '_meta' in params) {
+                const record = params;
+                const meta = record._meta;
+                if (meta !== undefined &&
+                    meta !== null &&
+                    (typeof meta !== 'object' || Array.isArray(meta))) {
+                    throw new Error('Invalid ACP request metadata');
+                }
+                const { _meta: _ignored, ...domainParams } = record;
+                return decode(domainParams);
+            }
+            return decode(params);
+        }
+        catch {
+            throw RequestError.invalidParams({ source: 'adapter', operation, code: 'invalid_request' }, `Invalid ${operation} request`);
+        }
+    };
 }
 function sessionContext(client, signal, capabilities, turnStatus = false) {
     return {
@@ -104,5 +138,11 @@ function sessionContext(client, signal, capabilities, turnStatus = false) {
                 notifyTurnStatus: (status) => client.notify('_maka/turn/status', status),
             }
             : {}),
+        ...(capabilities._meta?.['_maka/goalPlanStatus'] === true
+            ? {
+                notifyGoalStatus: (status) => client.notify('_maka/goal/status', status),
+                notifyPlanChanged: (status) => client.notify('_maka/plan/changed', status),
+            }
+            : {}),
     };
 }

package/dist/acp/session-domain-observation.js

@@ -0,0 +1,185 @@
+/*
+ * 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.
+ */
+/** Latest authoritative domain state for one retained Session attachment. */
+export class AcpSessionDomainObservation {
+    #sessionId;
+    #queryPlan;
+    #goalNotify;
+    #planNotify;
+    #disposed = false;
+    #epoch = 0;
+    #goal = null;
+    #goalKnown = false;
+    #goalDelivered;
+    #planDelivered;
+    #planSeen;
+    #planDirty = false;
+    #planRefresh;
+    #planRetryCount = 0;
+    #planRetryTimer;
+    #goalDelivery;
+    #planDelivery;
+    #pendingGoal;
+    #pendingPlan;
+    constructor(options) {
+        this.#sessionId = options.sessionId;
+        this.#queryPlan = options.queryPlan;
+        this.#goalNotify = options.goalNotify;
+        this.#planNotify = options.planNotify;
+    }
+    initialize(goal) {
+        this.goalChanged(goal);
+        this.planChanged();
+    }
+    goalChanged(goal) {
+        if (this.#disposed)
+            return;
+        if (this.#goalKnown &&
+            goal?.goalId === this.#goal?.goalId &&
+            (goal?.revision ?? -1) < (this.#goal?.revision ?? -1))
+            return;
+        this.#goalKnown = true;
+        this.#goal = goal;
+        // Even a return to the last delivered value must replace an older pending
+        // snapshot: an in-flight notification may still change what the client sees.
+        this.#pendingGoal = { sessionId: this.#sessionId, goal };
+        this.#sendGoal();
+    }
+    planChanged() {
+        if (this.#disposed)
+            return;
+        if (!this.#planNotify())
+            return;
+        if (this.#planRetryTimer) {
+            clearTimeout(this.#planRetryTimer);
+            this.#planRetryTimer = undefined;
+        }
+        this.#planRetryCount = 0;
+        this.#planDirty = true;
+        this.#kickPlan();
+    }
+    #kickPlan() {
+        if (!this.#planRefresh) {
+            this.#planRefresh = this.#refreshPlan().finally(() => {
+                this.#planRefresh = undefined;
+                if (this.#planDirty && !this.#disposed && !this.#planRetryTimer && this.#planRetryCount < 4)
+                    this.#kickPlan();
+            });
+        }
+    }
+    canonicalReplacement(goal) {
+        this.#epoch += 1;
+        this.#goalDelivered = undefined;
+        this.#planDelivered = undefined;
+        this.#planSeen = undefined;
+        this.#goalKnown = false;
+        this.initialize(goal);
+    }
+    dispose() {
+        this.#disposed = true;
+        this.#epoch += 1;
+        this.#pendingGoal = undefined;
+        this.#pendingPlan = undefined;
+        this.#planDirty = false;
+        if (this.#planRetryTimer)
+            clearTimeout(this.#planRetryTimer);
+        this.#planRetryTimer = undefined;
+    }
+    async #refreshPlan() {
+        // A frame received during a read is folded into one follow-up read.
+        while (this.#planDirty && !this.#disposed) {
+            this.#planDirty = false;
+            const epoch = this.#epoch;
+            try {
+                const result = await this.#queryPlan();
+                if (this.#disposed || epoch !== this.#epoch || result.kind !== 'page')
+                    continue;
+                this.#planRetryCount = 0;
+                if (this.#planSeen !== undefined && result.storeVersion < this.#planSeen)
+                    continue;
+                this.#planSeen = result.storeVersion;
+                const status = {
+                    sessionId: this.#sessionId,
+                    storeVersion: result.storeVersion,
+                    latestProposalId: result.latestProposalId,
+                    activeExecutionId: result.activeExecutionId,
+                };
+                if (result.storeVersion !== this.#planDelivered) {
+                    this.#pendingPlan = status;
+                    this.#sendPlan();
+                }
+            }
+            catch (error) {
+                console.error('[acp] Plan status refresh failed:', error);
+                this.#planDirty = true;
+                this.#planRetryCount += 1;
+                if (this.#planRetryCount <= 3 && !this.#disposed) {
+                    this.#planRetryTimer = setTimeout(() => {
+                        this.#planRetryTimer = undefined;
+                        this.#kickPlan();
+                    }, 25 * 2 ** (this.#planRetryCount - 1));
+                }
+                break;
+            }
+        }
+    }
+    #sendGoal() {
+        if (this.#goalDelivery || !this.#pendingGoal || this.#disposed)
+            return;
+        const notify = this.#goalNotify();
+        if (!notify)
+            return;
+        const status = this.#pendingGoal;
+        const epoch = this.#epoch;
+        this.#pendingGoal = undefined;
+        const key = JSON.stringify(status);
+        if (key === this.#goalDelivered)
+            return;
+        this.#goalDelivery = notify(status)
+            .then(() => {
+            if (!this.#disposed && epoch === this.#epoch)
+                this.#goalDelivered = key;
+        })
+            .catch((error) => console.error('[acp] Goal status delivery failed:', error))
+            .finally(() => {
+            this.#goalDelivery = undefined;
+            this.#sendGoal();
+        });
+    }
+    #sendPlan() {
+        if (this.#planDelivery || !this.#pendingPlan || this.#disposed)
+            return;
+        const notify = this.#planNotify();
+        if (!notify)
+            return;
+        const status = this.#pendingPlan;
+        const epoch = this.#epoch;
+        this.#pendingPlan = undefined;
+        this.#planDelivery = notify(status)
+            .then(() => {
+            if (!this.#disposed && epoch === this.#epoch)
+                this.#planDelivered = status.storeVersion;
+        })
+            .catch((error) => console.error('[acp] Plan status delivery failed:', error))
+            .finally(() => {
+            this.#planDelivery = undefined;
+            this.#sendPlan();
+        });
+    }
+}

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

@@ -35,7 +35,7 @@ export class AcpSessionEventMapper {
         this.#sessionId = options.sessionId;
         this.#notify = options.notify;
         this.#signal = options.signal;
-        this.#tools = new AcpToolEventMapper((update) => this.#deliver({ sessionId: this.#sessionId, update }));
+        this.#tools = new AcpToolEventMapper((update) => this.#deliver({ sessionId: this.#sessionId, update }), this.#sessionId);
     }
     accept(event) {
         return this.#enqueue(async () => {