maka-agent 0.2.1-dev.91.20261018 → 0.2.2-dev.97.20261024

package/node_modules/@maka/eval/node_modules/undici/lib/web/websocket/receiver.js

@@ -16,6 +16,7 @@ const { failWebsocketConnection } = require('./connection')
 const { WebsocketFrameSend } = require('./frame')
 const { PerMessageDeflate } = require('./permessage-deflate')
 const { MessageSizeExceededError } = require('../../core/errors')
+const { defaultWebSocketMaxFragments, defaultWebSocketMaxPayloadSize } = require('../../core/constants')
 
 // This code was influenced by ws released under the MIT license.
 // Copyright (c) 2011 Einar Otto Stangvik <einaros@gmail.com>
@@ -48,18 +49,25 @@ class ByteParser extends Writable {
   /**
    * @param {import('./websocket').Handler} handler
    * @param {Map<string, string>|null} extensions
-   * @param {{ maxPayloadSize?: number }} [options]
+   * @param {{ maxFragments?: number, maxPayloadSize?: number }} [options]
+   *   A missing value uses the default limit; `0` disables the limit.
    */
   constructor (handler, extensions, options = {}) {
     super()
 
     this.#handler = handler
     this.#extensions = extensions == null ? new Map() : extensions
-    this.#maxFragments = options.maxFragments ?? 0
-    this.#maxPayloadSize = options.maxPayloadSize ?? 0
+    // Options come from the dispatcher's `webSocketOptions`, which only
+    // DispatcherBase provides. Fall back to the defaults rather than to no
+    // limit, so RetryAgent, MockAgent or a custom dispatcher can't turn off
+    // the payload and decompression limits by accident.
+    this.#maxFragments = options.maxFragments ?? defaultWebSocketMaxFragments
+    this.#maxPayloadSize = options.maxPayloadSize ?? defaultWebSocketMaxPayloadSize
 
     if (this.#extensions.has('permessage-deflate')) {
-      this.#extensions.set('permessage-deflate', new PerMessageDeflate(extensions, options))
+      this.#extensions.set('permessage-deflate', new PerMessageDeflate(extensions, {
+        maxPayloadSize: this.#maxPayloadSize
+      }))
     }
   }
 
@@ -244,6 +252,19 @@ class ByteParser extends Writable {
         if (isControlFrame(this.#info.opcode)) {
           this.#loop = this.parseControlFrame(body)
           this.#state = parserStates.INFO
+
+          // If the automatic PONG/CLOSE reply filled the socket's write buffer,
+          // stop parsing and resume on drain so a PING flood cannot grow the
+          // outbound queue without bound.
+          if (this.#loop && this.#handler.socket.writableNeedDrain) {
+            this.#loop = false
+            this.#handler.socket.once('drain', () => {
+              if (this.destroyed) return
+              this.#loop = true
+              this.run(callback)
+            })
+            return
+          }
         } else {
           if (!this.#info.compressed) {
             if (!this.writeFragments(body)) {

package/node_modules/@maka/eval/node_modules/undici/package.json

@@ -1,6 +1,6 @@
 {
   "name": "undici",
-  "version": "8.11.2",
+  "version": "8.12.3",
   "description": "An HTTP/1.1 client, written from scratch for Node.js",
   "homepage": "https://undici.nodejs.org",
   "bugs": {
@@ -63,13 +63,15 @@
   "types": "index.d.ts",
   "scripts": {
     "build:node": "esbuild index-fetch.js --bundle --platform=node --outfile=undici-fetch.js --define:esbuildDetection=1 --keep-names && node scripts/strip-comments.js",
-    "build:wasm": "node build/wasm.js --docker",
+    "build:milo": "node build/milo.js",
+    "build:llhttp": "node build/llhttp.js --docker",
+    "build:wasm": "node build/llhttp.js --docker",
     "generate-pem": "node scripts/generate-pem.js",
     "lint": "eslint --cache",
     "lint:fix": "eslint --fix --cache",
     "test": "npm run test:javascript && cross-env NODE_V8_COVERAGE= npm run test:typescript",
     "test:javascript": "npm run test:javascript:no-jest && npm run test:jest",
-    "test:javascript:no-jest": "npm run generate-pem && npm run test:unit && npm run test:fetch && npm run test:node-fetch && npm run test:infra && npm run test:cache && npm run test:cache-interceptor && npm run test:interceptors && npm run test:cookies && npm run test:eventsource && npm run test:subresource-integrity && npm run test:wpt && npm run test:websocket && npm run test:node-test && npm run test:cache-tests",
+    "test:javascript:no-jest": "npm run generate-pem && npm run test:unit && npm run test:fetch && npm run test:node-fetch && npm run test:infra && npm run test:cache && npm run test:cache-interceptor && npm run test:interceptors && npm run test:cookies && npm run test:eventsource && npm run test:subresource-integrity && npm run test:websocket && npm run test:node-test && npm run test:cache-tests",
     "test:javascript:without-intl": "npm run test:javascript:no-jest",
     "test:busboy": "borp --timeout 180000 -p \"test/busboy/*.js\"",
     "test:cache": "borp --timeout 180000 -p \"test/cache/*.js\"",
@@ -97,7 +99,7 @@
     "test:websocket:autobahn": "node test/autobahn/client.js",
     "test:websocket:autobahn:report": "node test/autobahn/report.js",
     "test:wpt:setup": "node test/web-platform-tests/wpt-runner.mjs setup",
-    "test:wpt": "npm run test:wpt:setup && node test/web-platform-tests/wpt-runner.mjs run /fetch /mimesniff /xhr /websockets /eventsource",
+    "test:wpt": "npm run test:wpt:setup && node test/web-platform-tests/wpt-runner.mjs run /fetch /mimesniff /xhr /websockets /eventsource /service-workers",
     "test:cache-tests": "node test/cache-interceptor/cache-tests.mjs --ci",
     "coverage": "npm run coverage:clean && cross-env NODE_V8_COVERAGE=./coverage/tmp npm run test:javascript && npm run coverage:report",
     "coverage:ci": "npm run coverage:clean && cross-env NODE_V8_COVERAGE=./coverage/tmp npm run test:javascript && npm run coverage:report:ci",
@@ -109,7 +111,7 @@
     "prepare": "husky && node ./scripts/platform-shell.js"
   },
   "devDependencies": {
-    "@fastify/busboy": "3.2.2",
+    "@fastify/busboy": "3.2.3",
     "@matteo.collina/tspl": "^0.2.0",
     "@metcoder95/https-pem": "^1.0.0",
     "@sinonjs/fake-timers": "^12.0.0",
@@ -120,12 +122,12 @@
     "cross-env": "^10.0.0",
     "dns-packet": "^5.4.0",
     "esbuild": "^0.28.0",
-    "eslint": "^9.9.0",
+    "eslint": "^10.12.0",
     "fast-check": "^4.1.1",
     "husky": "^9.0.7",
     "jest": "^30.0.5",
     "jsondiffpatch": "^0.7.3",
-    "neostandard": "^0.13.0",
+    "neostandard": "^0.14.0",
     "node-forge": "^1.3.1",
     "proxy": "^4.0.0",
     "tsd": "^0.33.0",

package/node_modules/@maka/mcp/package.json

@@ -10,6 +10,6 @@
   },
   "dependencies": {
     "@maka/core": "0.1.0",
-    "@modelcontextprotocol/client": "2.2.0"
+    "@modelcontextprotocol/client": "2.3.0"
   }
 }

package/node_modules/@maka/runtime/dist/agent-run.js

@@ -1179,7 +1179,11 @@ export class AgentRun {
             return { kind: 'scheduled_task', scheduledTaskId: origin.scheduledTaskId };
         }
         if (origin?.kind === 'goal')
-            return { kind: 'goal', goalId: origin.goalId };
+            return {
+                kind: 'goal',
+                goalId: origin.goalId,
+                ...(origin.eventWait ? { eventWait: origin.eventWait } : {}),
+            };
         if (origin?.kind === 'agent_graph') {
             return {
                 kind: 'agent_graph_supervisor_wake',

package/node_modules/@maka/runtime/dist/agent-swarm-status-tool.js

@@ -98,7 +98,6 @@ export function buildAgentSwarmStatusTool(input) {
         description: 'Read compact status-only progress for the asynchronous swarm. This omits child logs, tool activity, reasoning, and partial output.',
         parameters: z.object({}).strip(),
         categoryHint: 'read',
-        recoveryMode: 'replay_safe',
         impl: async () => projectAgentSwarmStatus(await input.readSnapshot()),
     };
 }

package/node_modules/@maka/runtime/dist/ai-sdk-compaction.js

@@ -518,7 +518,8 @@ export class AiSdkCompaction {
         const priorContentEvents = (input.runtimeContext ?? [])
             .filter((event) => handoff || event.turnId !== input.turnId)
             .filter(isHistoryCompactContentEvent);
-        const state = new MidTurnCapacityCompactState(headAnchor, priorContentEvents, input.runtimeContextInvocations ?? [], resolveDeclaredContextWindow(this.input.connection, this.input.modelId));
+        const state = new MidTurnCapacityCompactState(headAnchor, priorContentEvents, input.runtimeContextInvocations ?? [], resolveDeclaredContextWindow(this.input.connection, this.input.modelId) ??
+            policy.historyCompact.midTurn.fallbackThresholdTokens);
         // Seed the turn's FIRST request with the last request the provider
         // actually counted, so step 0 is judged by the same real number as every
         // later step. No anchor means no proactive fold on step 0; the provider
@@ -535,12 +536,12 @@ export class AiSdkCompaction {
     /**
      * Request-projection stage for proactive compaction: before each request of
      * one turn, compare the baseline — the last provider-accepted request's real
-     * input plus real output tokens — against the context window the user
-     * declared, and over it fold a safe completed prefix into a durable
-     * checkpoint, continuing the turn on `[compact block, verbatim head anchor]`.
+     * input plus real output tokens — against the user's compaction target or
+     * explicit Host fallback. Crossing it folds a safe completed prefix into a
+     * durable checkpoint, continuing on `[compact block, verbatim head anchor]`.
      *
      * Nothing here estimates whether a request fits: the baseline is the
-     * provider's own count, the window is the user's own number, and the part of
+     * provider's own count, the target is a policy choice, and the part of
      * the next request neither describes (tool results, user text, images
      * appended since) is judged by the provider when the request goes out. This
      * hook never terminates the turn: every failure fails open with a diagnostic
@@ -599,7 +600,7 @@ export class AiSdkCompaction {
                 return keepProjection();
             };
             // One trigger, one real signal: the baseline plus the room the next reply
-            // needs crossed the window the user declared. A cut reply is deliberately
+            // needs crossed the user target or Host fallback. A cut reply is deliberately
             // not a trigger — see the note on `finishReason: length` in the backend.
             // The next request is at least the baseline, and its reply needs room on
             // top of it. The room is measured from the last reply the model actually
@@ -883,10 +884,10 @@ export class AiSdkCompaction {
     /**
      * Reactive overflow recovery (issue #882 PR 2): the second line of defense.
      * When a provider rejects a request with a context-length error, fold the
-     * durable turn ledger and resend — once per step: a step that a fold or an
-     * image omission has already reshaped gets no second recovery, so the
-     * resend's own rejection is terminal, while a step the provider has since
-     * accepted earns a fresh attempt. Returns the compacted messages to resend,
+     * durable turn ledger and resend. Each step may omit historical images once,
+     * then fold once; a rejection after the fold is terminal. A step the
+     * provider has since accepted earns a fresh recovery sequence. Returns the
+     * compacted messages to resend,
      * or undefined when recovery is impossible or already spent, in which case
      * the caller surfaces the real provider error rather than a fabricated
      * success or a locally synthesized verdict (the provider — not the runtime —
@@ -896,12 +897,14 @@ export class AiSdkCompaction {
      */
     async recoverFromOverflowError(input) {
         const state = input.midTurnState;
-        if (!state || state.stepShaping.has('fold') || state.stepShaping.has('omit_images')) {
+        if (!state || state.stepShaping.has('fold')) {
             return undefined;
         }
         const eligibleImages = collectHistoricalImageToolResults(state.priorContentEvents);
-        const imageOmission = omitHistoricalImageToolResults(input.currentMessages, eligibleImages);
-        if (imageOmission.omittedParts > 0) {
+        const imageOmission = state.stepShaping.has('omit_images')
+            ? undefined
+            : omitHistoricalImageToolResults(input.currentMessages, eligibleImages);
+        if (imageOmission && imageOmission.omittedParts > 0) {
             state.stepShaping.add('omit_images');
             for (const toolCallId of imageOmission.omittedToolCallIds) {
                 const image = eligibleImages.get(toolCallId);
@@ -911,6 +914,15 @@ export class AiSdkCompaction {
                 if (image)
                     state.omittedImageToolResults.set(toolCallId, image);
             }
+            input.onDiagnosticPatch(compactionDecisionDiagnosticPatch({
+                stage: 'activeStep',
+                sourceKind: 'providerMessages',
+                decision: 'replaced',
+                phase: state.compactionPhase(input.stepNumber),
+                boundaryKind: 'imageOmission',
+                coverage: { toolCallIds: [...imageOmission.omittedToolCallIds] },
+                reason: 'overflow',
+            }));
             state.baselineTokens = undefined;
             return { messages: imageOmission.messages };
         }
@@ -961,7 +973,9 @@ export class AiSdkCompaction {
         // The fold replaced the request; the baseline described the rejected one.
         state.stepShaping.add('fold');
         state.baselineTokens = undefined;
-        return { messages: outcome.replacementMessages };
+        return {
+            messages: projectHistoricalImageOmissions(outcome.replacementMessages, state.omittedImageToolResults) ?? outcome.replacementMessages,
+        };
     }
 }
 function projectHistoricalImageOmissions(messages, omittedImageToolResults) {
@@ -1047,7 +1061,7 @@ export class MidTurnCapacityCompactState {
     /**
      * What has reshaped the request since the last one a provider accepted. The
      * turn clears it at that acceptance; overflow recovery reads it so a request
-     * that was already folded or stripped of images is not reshaped again.
+     * is folded at most once, after an optional image omission.
      */
     stepShaping = new Set();
     /**

package/node_modules/@maka/runtime/dist/ai-sdk-message-projection.js

@@ -19,8 +19,9 @@
 import { MAX_PROVIDER_IMAGE_REQUEST_BYTES, PROVIDER_IMAGE_BUDGET_EXCEEDED_MESSAGE, } from '@maka/core/attachments';
 import { applyPatchReplayFactText, normalizeApplyPatchReplayInput, } from './apply-patch-profile.js';
 import { durableProjectionToToolResultOutput } from './durable-tool-result-projection.js';
+import { runtimeContextMessage } from './runtime-context.js';
 import { historyCompactCheckpointToModelMessage, isProviderHistoryCompactCheckpoint, } from './history-compact-checkpoint.js';
-import { admitProviderReasoningReplayItems, buildRuntimeEventReplayTimeline, formatTextWithInlineRefs, steeringProviderOptions, } from './model-history.js';
+import { admitProviderReasoningReplayItems, buildRuntimeEventReplayTimeline, formatTextWithInlineRefs, steeringProviderOptions, runtimeContextProviderOptions, } from './model-history.js';
 import { openAiChatReasoningFieldFromProviderOptions } from './openai-chat-reasoning-transport.js';
 import { decodePlaintextResponsesReasoningState, replayPlaintextResponsesProviderOptions, } from './responses-reasoning-state.js';
 import { toolResultOutput } from './tool-result-output.js';
@@ -464,6 +465,11 @@ export class AiSdkMessageProjection {
         messages.push(message);
         this.memoryReplayMessageEvents.set(message, [...new Set(eventIds)]);
     }
+    materializeRuntimeContext(context, eventId) {
+        const message = runtimeContextMessage(context);
+        this.memoryReplayMessageEvents.set(message, [eventId]);
+        return message;
+    }
     memoryEventMessagePositions(messages) {
         const positions = {};
         for (const [position, message] of messages.entries()) {
@@ -492,6 +498,9 @@ export class AiSdkMessageProjection {
             return {
                 role: 'user',
                 content,
+                ...(item.runtimeContextName !== undefined
+                    ? { providerOptions: runtimeContextProviderOptions(item.runtimeContextName) }
+                    : {}),
             };
         }
         return {