maka-agent 0.2.1-dev.89.20261016 → 0.2.1-dev.90.20261017

package/node_modules/@maka/core/dist/event-wait.js

@@ -29,7 +29,12 @@ export const EVENT_WAIT_LIMITS = Object.freeze({
     evidenceRefs: 8,
     evidenceRefBytes: 1024,
     reasonBytes: 1024,
-    recordBytes: 32768,
+    cursorBytes: 2048,
+    observationAttempts: 1_000_000,
+    // Every combination of bounded fields, including observation and a cancelled
+    // priorResolution, fits below 42 KiB even with JSON escaping. Leave room for
+    // the full lifecycle so an accepted result can always retain its facts on cancel.
+    recordBytes: 48 * 1024,
 });
 const encoder = new TextEncoder();
 const invalidIdCharacterPattern = /[^A-Za-z0-9_-]/u;
@@ -187,7 +192,7 @@ export function decodeEventWaitRecord(value) {
         'deadlineAt',
         'status',
         ...lifecycleKeys,
-    ], root.status === 'cancelled' ? ['priorResolution'] : []);
+    ], root.status === 'cancelled' ? ['priorResolution', 'observation'] : ['observation']);
     if (r.schemaVersion !== EVENT_WAIT_SCHEMA_VERSION)
         invalid('schemaVersion');
     const lease = shape(r.goalControlLease, ['goalId', 'generation']);
@@ -230,6 +235,62 @@ export function decodeEventWaitRecord(value) {
             invalid('lifecycle time');
         return result;
     };
+    if (Object.hasOwn(r, 'observation')) {
+        const x = shape(r.observation, [
+            'schemaVersion',
+            'attempts',
+            'lastAttemptAt',
+            'lastObservedAt',
+            'nextObserveAt',
+            'nextPollAt',
+            'consecutiveErrors',
+            'outcome',
+            'cursor',
+            'eventKey',
+            'reason',
+        ]);
+        const attempts = integer(x.attempts, 'observation attempts', 1);
+        const consecutiveErrors = integer(x.consecutiveErrors, 'consecutive errors');
+        const lastAttemptAt = time(x.lastAttemptAt);
+        const nextObserveAt = integer(x.nextObserveAt, 'next observation');
+        const nextPollAt = integer(x.nextPollAt, 'next poll');
+        const lastObservedAt = x.lastObservedAt === null ? null : time(x.lastObservedAt);
+        if (x.schemaVersion !== 1 ||
+            attempts > EVENT_WAIT_LIMITS.observationAttempts ||
+            consecutiveErrors > attempts ||
+            nextObserveAt < lastAttemptAt ||
+            nextPollAt < nextObserveAt ||
+            (x.outcome !== 'checking' && (lastObservedAt === null || lastObservedAt < lastAttemptAt)) ||
+            typeof x.outcome !== 'string' ||
+            ![
+                'checking',
+                'pending',
+                'unknown',
+                'satisfied',
+                'invalidated',
+                'source_unavailable',
+            ].includes(x.outcome))
+            invalid('observation');
+        Object.assign(base, {
+            observation: {
+                schemaVersion: 1,
+                attempts,
+                lastAttemptAt,
+                lastObservedAt,
+                nextObserveAt,
+                nextPollAt,
+                consecutiveErrors,
+                outcome: x.outcome,
+                cursor: x.cursor === null ? null : text(x.cursor, 'cursor', EVENT_WAIT_LIMITS.cursorBytes),
+                eventKey: x.eventKey === null
+                    ? null
+                    : text(x.eventKey, 'event key', EVENT_WAIT_LIMITS.receiptKeyBytes),
+                reason: x.reason === null
+                    ? null
+                    : text(x.reason, 'observation reason', EVENT_WAIT_LIMITS.reasonBytes),
+            },
+        });
+    }
     const resolution = (v, resolvedAt) => {
         const x = shape(v, ['outcome', 'receiptKey', 'observedAt', 'evidenceRefs']);
         if (x.outcome !== 'satisfied' &&
@@ -306,7 +367,41 @@ export function assertEventWaitTransition(previous, next) {
     }
     if (b.updatedAt < a.updatedAt)
         invalid('time regression');
+    if (a.observation) {
+        if (!b.observation ||
+            b.observation.attempts < a.observation.attempts ||
+            b.observation.attempts > a.observation.attempts + 1 ||
+            b.observation.lastAttemptAt < a.observation.lastAttemptAt ||
+            (a.observation.lastObservedAt !== null &&
+                (b.observation.lastObservedAt === null ||
+                    b.observation.lastObservedAt < a.observation.lastObservedAt)))
+            invalid('observation regression');
+        if (b.observation.attempts === a.observation.attempts &&
+            b.observation.lastAttemptAt !== a.observation.lastAttemptAt)
+            invalid('attempt time without reservation');
+        if (b.observation.attempts > a.observation.attempts &&
+            (b.status !== 'waiting' ||
+                b.observation.outcome !== 'checking' ||
+                b.observation.lastObservedAt !== a.observation.lastObservedAt ||
+                b.observation.cursor !== a.observation.cursor ||
+                b.observation.eventKey !== a.observation.eventKey ||
+                b.observation.consecutiveErrors !== a.observation.consecutiveErrors))
+            invalid('attempt reservation');
+    }
+    else if (b.observation && b.observation.attempts !== 1)
+        invalid('initial observation budget');
     if (a.status === 'waiting') {
+        if (b.status === 'waiting' && b.observation && !same(a.observation, b.observation)) {
+            if (b.observation.attempts > (a.observation?.attempts ?? 0) &&
+                b.observation.outcome === 'checking')
+                return;
+            if (a.observation?.outcome === 'checking' &&
+                (b.observation.outcome === 'pending' || b.observation.outcome === 'unknown'))
+                return;
+            invalid('observation update without reservation');
+        }
+        if (b.status === 'resolved' && b.resolvedAt >= b.deadlineAt)
+            invalid('resolution after deadline');
         if (b.status === 'resolved' ||
             b.status === 'expired' ||
             (b.status === 'cancelled' && !b.priorResolution))
@@ -314,6 +409,7 @@ export function assertEventWaitTransition(previous, next) {
     }
     else if (a.status === 'resolved' &&
         b.status === 'cancelled' &&
+        same(a.observation, b.observation) &&
         same(b.priorResolution, { resolvedAt: a.resolvedAt, resolution: a.resolution }))
         return;
     invalid('state transition');

package/node_modules/@maka/runtime/dist/plugin-executor-backend.js

@@ -59,8 +59,8 @@ export class PluginExecutorBackend {
                 yield event;
                 queue.ackConsumed();
             }
-            const returnedResult = await producer;
-            if (returnedResult) {
+            const settlement = await producer;
+            if (settlement === 'published') {
                 // The Runtime Kernel requests the next item only after onSessionEvent
                 // resolves. Reaching this point means its terminal event was accepted.
                 // The Plugin decides whether its external execution actually settled;
@@ -78,8 +78,11 @@ export class PluginExecutorBackend {
         finally {
             queue.noteConsumerDetached();
             abort.abort(new Error('Plugin executor event consumer detached'));
-            const returnedResult = await producer.catch(() => false);
-            if (returnedResult &&
+            // A settled result that was not acknowledged is abandoned, including one
+            // the Runtime rejected before publishing it. A provider failure before
+            // settlement is neither acknowledged nor abandoned.
+            const settlement = await producer.catch(() => 'unsettled');
+            if (settlement !== 'unsettled' &&
                 this.#binding.acknowledgeExecution &&
                 !acknowledged &&
                 this.#binding.abandonExecution)
@@ -113,6 +116,7 @@ export class PluginExecutorBackend {
         let result;
         let failure;
         let failed = false;
+        let settled = false;
         try {
             result = await this.#binding.execute({
                 sessionId: this.sessionId,
@@ -130,6 +134,9 @@ export class PluginExecutorBackend {
                 ...(input.quotes ? { quotes: input.quotes } : {}),
             }, {
                 signal,
+                onSettled: () => {
+                    settled = true;
+                },
                 onEvent: (event) => {
                     if (event.type === 'thinking_delta')
                         thinkingText += event.text;
@@ -148,14 +155,14 @@ export class PluginExecutorBackend {
                 this.#publishCancellation(turnId, { status: 'cancelled', source: 'caller' }, queue);
             else
                 this.#publishFailure(turnId, failure instanceof Error ? failure.message : 'External executor failed', undefined, false, queue);
-            return false;
+            return settled ? 'rejected' : 'unsettled';
         }
         if (result === undefined) {
             this.#publishFailure(turnId, 'External executor returned no terminal result', undefined, false, queue);
-            return false;
+            return settled ? 'rejected' : 'unsettled';
         }
         this.#publishResult(turnId, messageId, result, queue);
-        return true;
+        return 'published';
     }
     async #requestPermission(input, request, signal, toolUseIds, queue) {
         const hosted = input.hostedInteraction;

package/node_modules/@maka/runtime/dist/plugin-executor-service.js

@@ -280,6 +280,12 @@ export class PluginExecutorService extends Service {
                         return normalizePermissionResult(result, normalized);
                     },
                 });
+                try {
+                    options.onSettled?.();
+                }
+                catch {
+                    // A settlement observer must not change external execution.
+                }
                 if (signal.aborted) {
                     const cancelled = cancelledResult(signal.reason);
                     const normalized = normalizeResult(result);

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

@@ -27,25 +27,6 @@ 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.
  *

package/node_modules/@maka/runtime-host/dist/server/event-wait-adapter.js

@@ -0,0 +1,47 @@
+/*
+ * 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.
+ */
+function key(provider, resource, condition, version) {
+    return JSON.stringify([provider, resource, condition, version]);
+}
+export class EventWaitAdapterRegistry {
+    #adapters = new Map();
+    constructor(adapters) {
+        for (const adapter of adapters) {
+            if (!['snapshot', 'history'].includes(adapter.reconciliation) ||
+                !Number.isSafeInteger(adapter.conditionVersion) ||
+                adapter.conditionVersion < 1 ||
+                [adapter.providerId, adapter.resourceType, adapter.conditionType].some((v) => typeof v !== 'string' || !/^[A-Za-z0-9_.-]{1,128}$/.test(v)))
+                throw new TypeError('Invalid event wait adapter');
+            const id = key(adapter.providerId, adapter.resourceType, adapter.conditionType, adapter.conditionVersion);
+            if (this.#adapters.has(id))
+                throw new TypeError('Duplicate event wait adapter');
+            this.#adapters.set(id, adapter);
+        }
+    }
+    get(wait) {
+        return this.#adapters.get(key(wait.resource.providerId, wait.resource.resourceType, wait.condition.typeId, wait.condition.version));
+    }
+    validate(wait) {
+        const adapter = this.get(wait);
+        if (!adapter)
+            throw new TypeError('Unsupported event wait condition');
+        adapter.validate(wait);
+        return adapter;
+    }
+}