maka-agent 0.2.0-dev.31.20260913 → 0.2.0-dev.32.20260914

package/node_modules/@maka/runtime/dist/background-task-health-tool.js

@@ -0,0 +1,104 @@
+/*
+ * 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 { z } from 'zod';
+/**
+ * Produces an explicit two-axis result. A tracked process is never described
+ * as endpoint-ready unless the caller supplied a URL and the probe succeeded.
+ */
+export function buildBackgroundTaskHealthTool(reader, probe) {
+    return {
+        name: 'BackgroundTaskHealth',
+        displayName: 'Background task health',
+        categoryHint: 'web_read',
+        description: 'Check a tracked background task and an optional HTTP endpoint. Uses HEAD with one GET fallback for 405/501; discards the body. Reports HTTP status only, not browser loading or ownership of the listener. Redirects are not followed. Logs are omitted by default; use Read(ref) for full logs.',
+        parameters: z
+            .object({
+            ref: z.string().describe('The maka://runtime/background-tasks/<id> ref returned by Bash'),
+            include_logs: z.boolean().optional().describe('Include captured task logs in this report'),
+            url: z
+                .string()
+                .url()
+                .refine((value) => ['http:', 'https:'].includes(new URL(value).protocol), 'Health endpoint must use HTTP or HTTPS')
+                .optional()
+                .describe('The HTTP or HTTPS endpoint to probe'),
+        })
+            .strict(),
+        impl: async ({ ref, url, include_logs }, context) => {
+            const resource = await reader.readRuntimeResource(context.sessionId, ref, context.abortSignal);
+            if (!resource ||
+                typeof resource !== 'object' ||
+                Array.isArray(resource) ||
+                resource.kind !== 'shell_run') {
+                throw new Error('BackgroundTaskHealth requires a shell_run runtime resource');
+            }
+            const shell = resource;
+            const process = {
+                status: shell.status,
+                tracked: true,
+                startedAt: shell.startedAt,
+                updatedAt: shell.updatedAt,
+                ...(shell.pid !== undefined ? { pid: shell.pid } : {}),
+                ...(shell.completedAt !== undefined ? { completedAt: shell.completedAt } : {}),
+                ...(shell.failureMessage !== undefined ? { failureMessage: shell.failureMessage } : {}),
+                ...(include_logs && shell.output
+                    ? {
+                        logs: shell.output.mode === 'pipes'
+                            ? { stdout: shell.output.stdout, stderr: shell.output.stderr }
+                            : { screen: shell.output.screen, scrollback: shell.output.scrollback },
+                    }
+                    : {}),
+            };
+            if (!url)
+                return JSON.stringify({ process, endpoint: { state: 'not_checked' } });
+            let endpoint;
+            try {
+                endpoint = await probe.probe({
+                    url,
+                    sessionId: context.sessionId,
+                    abortSignal: context.abortSignal,
+                });
+            }
+            catch (error) {
+                context.abortSignal.throwIfAborted();
+                return JSON.stringify({
+                    process,
+                    endpoint: {
+                        state: 'unknown',
+                        target: new URL(url).href,
+                        error: error instanceof Error ? error.message : String(error),
+                    },
+                });
+            }
+            return JSON.stringify({
+                process,
+                endpoint: {
+                    state: 'checked',
+                    httpStatus: endpoint.status,
+                    elapsedMs: endpoint.elapsedMs,
+                    target: new URL(url).href,
+                    health: endpoint.status >= 200 && endpoint.status < 300
+                        ? 'healthy'
+                        : endpoint.status < 400
+                            ? 'unknown'
+                            : 'unhealthy',
+                },
+            });
+        },
+    };
+}

package/node_modules/@maka/runtime/dist/history-compaction.js

@@ -120,7 +120,9 @@ function acceptedInputBoundary(events, invocations, route) {
         if (event?.role !== 'model')
             return false;
         const opened = invocations.find((candidate) => candidate.runId === event.runId)?.opening.route;
-        if (opened?.provenance !== 'runtime' || opened.modelId !== route.modelId)
+        if (opened?.provenance !== 'runtime' ||
+            opened.backendKind === 'plugin-executor' ||
+            opened.modelId !== route.modelId)
             return false;
         return opened.llmConnectionId === route.connectionId;
     };

package/node_modules/@maka/runtime/dist/local-web-fetch.js

@@ -119,7 +119,7 @@ export function createLocalWebFetchExecutor(input) {
 function responseLimitError() {
     return new Error('WebFetch response exceeds the 5 MB response limit.');
 }
-function assertAllowedTarget(url) {
+export function assertAllowedTarget(url) {
     if (url.protocol !== 'http:' && url.protocol !== 'https:') {
         throw new Error('WebFetch URL must use HTTP or HTTPS.');
     }

package/node_modules/@maka/runtime/dist/model-adapter.js

@@ -101,17 +101,22 @@ export class ModelAdapter {
         });
         const { streamText, wrapLanguageModel } = ai;
         const maxOutputTokens = selectedModelMaxOutputTokens(this.input.connection, this.input.modelId, this.input.providerOptions, this.runtime);
+        let settleAccounting;
+        const terminalModel = withProviderFinishBoundary(input.model, wrapLanguageModel);
         const trackedModel = input.providerRequestTracker
             ? withProviderStreamTracking({
-                model: input.model,
+                model: terminalModel,
                 wrapLanguageModel,
                 tracker: input.providerRequestTracker,
                 abortSignal: input.abortSignal,
+                onAttempt: (settle) => {
+                    settleAccounting = settle;
+                },
                 ...(input.historyCompactBoundary
                     ? { historyCompactBoundary: input.historyCompactBoundary }
                     : {}),
             })
-            : input.model;
+            : terminalModel;
         const usesOpenAiResponsesAdapter = hasOpenAiResponsesAdapter(this.runtime);
         const providerToolName = (name) => usesOpenAiResponsesAdapter && name === TOOL_SEARCH_NAME ? TOOL_SEARCH_PROVIDER_NAME : name;
         const runtimeToolName = (name) => usesOpenAiResponsesAdapter && name === TOOL_SEARCH_PROVIDER_NAME ? TOOL_SEARCH_NAME : name;
@@ -158,10 +163,6 @@ export class ModelAdapter {
             providerOptions,
             ...(responsesLane ? { headers: { [OPENAI_RESPONSES_LANE_HEADER]: responsesLane } } : {}),
             maxRetries: 0,
-            // Preserve the final request's Maka-owned message projection without
-            // retaining the provider request body. ProviderRequestTracker owns body
-            // capture; duplicating it here can retain large base64 image payloads.
-            include: { requestMessages: true },
             // With no continuation predicate, streamText performs one provider step.
             // Continuation belongs to the Runtime above this adapter.
             abortSignal: input.abortSignal,
@@ -176,6 +177,9 @@ export class ModelAdapter {
             requestMessages: fullMessages,
             abortSignal: input.abortSignal,
             runtimeToolName,
+            settleAccounting: async (outcome) => {
+                await settleAccounting?.(outcome);
+            },
         });
     }
     /**
@@ -194,7 +198,6 @@ export class ModelAdapter {
         const outcome = new Promise((resolve) => {
             settleOutcome = resolve;
         });
-        const request = { messages: continuation.requestMessages };
         const events = {
             async *[Symbol.asyncIterator]() {
                 let failure;
@@ -210,6 +213,10 @@ export class ModelAdapter {
                             chunk.type === 'step-finish') {
                             streamedRawFinishReason =
                                 rawFinishReasonString(chunk.rawFinishReason) ?? streamedRawFinishReason;
+                            streamedFinishReason = chunkFinishReason(chunk) ?? streamedFinishReason;
+                            if (chunk.type === 'finish')
+                                sawFinish = true;
+                            continue;
                         }
                         if (isUnfinalizedPlaintextSummaryReasoningEnd(chunk, resolvedRuntime)) {
                             // The SDK emits this trailer from flush() when no
@@ -223,11 +230,6 @@ export class ModelAdapter {
                         for (const event of translateChunk(chunk, openAiChatReasoningTransportState, resolvedRuntime, continuation.runtimeToolName)) {
                             if (event.kind === 'error')
                                 failure = event.failure;
-                            if (event.kind === 'finish')
-                                sawFinish = true;
-                            if (event.kind === 'finish' || event.kind === 'step-finish') {
-                                streamedFinishReason = event.finishReason ?? streamedFinishReason;
-                            }
                             yield event;
                         }
                     }
@@ -239,6 +241,9 @@ export class ModelAdapter {
                     }
                 }
                 finally {
+                    if (continuation.abortSignal.aborted) {
+                        failure = normalizeProviderFailure(continuation.abortSignal.reason);
+                    }
                     const [sdkUsage, sdkFinishReason] = await Promise.all([
                         sdk.usage.catch(() => undefined),
                         sdk.finishReason.catch(() => undefined),
@@ -263,7 +268,6 @@ export class ModelAdapter {
                         finishReason,
                         rawFinishReason,
                         usage,
-                        request,
                     });
                     let deferredFailure;
                     if (sawUnfinalizedPlaintextSummary && settled.kind === 'completed') {
@@ -276,7 +280,6 @@ export class ModelAdapter {
                             finishReason,
                             rawFinishReason,
                             usage,
-                            request,
                         });
                     }
                     try {
@@ -301,7 +304,12 @@ export class ModelAdapter {
                         }
                     }
                     finally {
-                        settleOutcome(settled);
+                        try {
+                            await continuation.settleAccounting(settled);
+                        }
+                        finally {
+                            settleOutcome(settled);
+                        }
                     }
                     if (deferredFailure) {
                         // Consumers may stop iterating at the first error. The outcome and
@@ -378,33 +386,32 @@ export class ModelAdapter {
     }
 }
 export function settleModelStepOutcome(evidence) {
-    const { aborted, failure, sawFinish, finishReason, rawFinishReason, usage, request } = evidence;
+    const { aborted, failure, sawFinish, finishReason, rawFinishReason, usage } = evidence;
     if (aborted || failure?.kind === 'abort') {
-        return failedStepOutcome('aborted', failure ??
-            normalizeProviderFailure(Object.assign(new Error('aborted'), { name: 'AbortError' })), request, usage);
+        return failedStepOutcome(failure ??
+            normalizeProviderFailure(Object.assign(new Error('aborted'), { name: 'AbortError' })), usage);
     }
     if (failure) {
-        return failedStepOutcome('failed', failure, request, usage);
+        return failedStepOutcome(failure, usage);
     }
     if (!sawFinish || finishReason === 'other' || finishReason === 'unknown') {
-        return failedStepOutcome('truncated', modelStepFailure('stream_truncated', `Provider stream ended without finishing (${finishReason})`), request, usage);
+        return failedStepOutcome(modelStepFailure('stream_truncated', `Provider stream ended without finishing (${finishReason})`), usage);
     }
     if (finishReason === 'content-filter' || finishReason === 'error') {
         const terminalFailure = finishReason === 'error'
             ? providerFinishFailure(rawFinishReason)
             : modelStepFailure('unknown', 'Provider stopped the stream on a content filter');
-        return failedStepOutcome('failed', terminalFailure, request, usage);
+        return failedStepOutcome(terminalFailure, usage);
     }
     return {
         kind: 'completed',
         finishReason,
         ...(usage ? { usage } : {}),
-        request,
         continuation: 'none',
     };
 }
 function modelStepFailure(kind, message) {
-    return { type: 'model_failure', kind, message, retryable: false };
+    return { type: 'model_failure', kind, message, retryable: kind === 'stream_truncated' };
 }
 function providerFinishFailure(rawFinishReason) {
     if (rawFinishReason && rawFinishReason !== 'error') {
@@ -424,12 +431,11 @@ function providerFinishFailure(rawFinishReason) {
     }
     return modelStepFailure('provider_unavailable', 'Provider stopped the stream with an error');
 }
-function failedStepOutcome(kind, failure, request, usage) {
+function failedStepOutcome(failure, usage) {
     return {
-        kind,
+        kind: 'failed',
         failure,
         ...(usage ? { usage } : {}),
-        request,
         continuation: 'none',
     };
 }
@@ -486,6 +492,35 @@ function requireResponsesReplayProfile(runtime) {
     }
     return runtime.responsesReplayProfile;
 }
+/**
+ * A provider `finish` part is the LanguageModel stream's terminal semantic
+ * boundary. Expose EOF at that boundary so the SDK can flush its public
+ * finish/usage promises even when the transport keeps the connection open.
+ */
+function withProviderFinishBoundary(model, wrapLanguageModel) {
+    return wrapLanguageModel({
+        model,
+        middleware: {
+            wrapStream: async ({ doStream, }) => {
+                const result = await doStream();
+                return {
+                    ...result,
+                    stream: result.stream.pipeThrough(new TransformStream({
+                        transform(part, controller) {
+                            controller.enqueue(part);
+                            if (part !== null &&
+                                typeof part === 'object' &&
+                                !Array.isArray(part) &&
+                                part.type === 'finish') {
+                                controller.terminate();
+                            }
+                        },
+                    })),
+                };
+            },
+        },
+    });
+}
 /**
  * The finish reason to forward, preferring what the provider actually said.
  *
@@ -750,33 +785,7 @@ function translateChunk(chunk, openAiChatReasoningTransportState, runtime, runti
         case 'tool-input-start':
         case 'tool-input-delta':
         case 'tool-input-end':
-            return chunk.providerExecuted === true ? [{ kind: 'provider-tool-input' }] : [];
-        // Step boundaries (`start-step` / `finish-step`) and the terminal `finish`
-        // carry no text/thinking to stream. The backend owns step accounting: it
-        // counts and flushes one AssistantMessage per step and rotates the
-        // messageId at each `finish-step`. `step-finish` is legacy replay fixture
-        // compatibility — handled as a step boundary, not a text carrier.
-        case 'finish-step':
-        case 'step-finish': {
-            const finishReason = chunkFinishReason(chunk);
-            const rawFinishReason = rawFinishReasonString(chunk.rawFinishReason);
-            // The same value the turn's outcome is decided from, so the record and
-            // the outcome cannot name different reasons for the same stream.
-            const usage = normalizeAiSdkUsage(chunk.usage, {
-                rawFinishReason: rawFinishReason ?? finishReason,
-            });
-            return [
-                {
-                    kind: 'step-finish',
-                    ...(usage ? { usage } : {}),
-                    ...(finishReason ? { finishReason } : {}),
-                },
-            ];
-        }
-        case 'finish': {
-            const finishReason = chunkFinishReason(chunk);
-            return [{ kind: 'finish', ...(finishReason ? { finishReason } : {}) }];
-        }
+            return [{ kind: 'tool-input', providerExecuted: chunk.providerExecuted === true }];
         case 'start-step':
         case 'tool-result':
         case 'tool-error': {

package/node_modules/@maka/runtime/dist/model-history.js

@@ -606,15 +606,11 @@ export function buildRuntimeEventModelReplayPlan(events, options = {}) {
             providerOptions: steeringProviderOptions(item.steering.eventId),
         }
         : { role: item.role, content: item.content });
-    const semanticKinds = [...new Set(items.map((item) => item.kind))];
     return {
         items,
         textMessages,
-        semanticKinds,
         diagnostics,
-        hasProviderNativeSemantics: semanticKinds.includes('thinking') ||
-            semanticKinds.includes('tool_call') ||
-            semanticKinds.includes('tool_result'),
+        hasProviderNativeSemantics: items.some((item) => item.kind !== 'text'),
     };
 }
 function modelTextRole(role) {