maka-agent 0.2.0-dev.47.20260922 → 0.2.0-dev.48.20260923

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

@@ -16,12 +16,14 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+import { isExecutorConfiguration, normalizeCatalogEntry, } from '@maka/core/executor-catalog';
 import { createHash } from 'node:crypto';
-import { TOOL_ACTIVITY_KINDS } from '@maka/core/events';
+import { TOOL_ACTIVITY_KINDS, TOOL_OUTPUT_STREAMS } from '@maka/core/events';
 import { isExecutorId } from '@maka/core/executor-id';
 import { Service } from './plugin-kernel.js';
 import { MakaPluginRuntimeError, pluginIdentity, registerPluginContribution, } from './plugin-runtime.js';
 import { PluginScopeRegistry } from './plugin-scope-registry.js';
+const MAX_EXECUTOR_COMPLETION_TEXT_BYTES = 256 * 1024;
 class ExecutorRetiredAbort extends Error {
     constructor(executorId) {
         super(`Executor was retired: ${executorId}`);
@@ -57,6 +59,16 @@ export class PluginExecutorService extends Service {
                 ...(provider.displayName === undefined ? {} : { displayName: provider.displayName }),
                 capabilities,
                 execute: provider.execute.bind(provider),
+                ...(provider.disposeConversation
+                    ? { disposeConversation: provider.disposeConversation.bind(provider) }
+                    : {}),
+                ...(provider.configureConversation
+                    ? { configureConversation: provider.configureConversation.bind(provider) }
+                    : {}),
+                ...(provider.discover ? { discover: provider.discover.bind(provider) } : {}),
+                ...(provider.inspectConversation
+                    ? { inspectConversation: provider.inspectConversation.bind(provider) }
+                    : {}),
             });
             const entry = {
                 ...identity,
@@ -99,6 +111,78 @@ export class PluginExecutorService extends Service {
             capabilities: normalizeCapabilities(provider.capabilities),
         })));
     }
+    /** Captures registrations before awaiting provider code; retirement cancels and drains probes. */
+    async catalog(input, signal = AbortSignal.timeout(35_000)) {
+        const scopeSessionId = input.sessionId ?? input.discoverySessionId;
+        const entries = scopeSessionId
+            ? [...this.registry.visible(scopeSessionId).values()]
+            : [...this.registry.entries('profile')];
+        const selected = entries.filter((entry) => !entry.retired && (!input.executorId || entry.provider.id === input.executorId));
+        if (input.executorId && !selected.length)
+            return [
+                {
+                    id: input.executorId,
+                    displayName: input.executorId,
+                    readiness: 'unavailable',
+                    models: [],
+                    supportsAttachments: false,
+                    supportsModelChange: false,
+                },
+            ];
+        return await Promise.all(selected.map((entry) => this.withActiveOperation(entry, { signal }, async (combined) => {
+            const fallback = {
+                id: entry.provider.id,
+                displayName: entry.provider.displayName ?? entry.provider.id,
+                readiness: 'ready',
+                models: [],
+                supportsAttachments: false,
+                supportsModelChange: false,
+            };
+            try {
+                combined.throwIfAborted();
+                const result = input.sessionId
+                    ? await entry.provider.inspectConversation?.({
+                        conversationKey: input.sessionId,
+                        cwd: input.cwd,
+                        ...(input.configuration ? { configuration: input.configuration } : {}),
+                    })
+                    : await entry.provider.discover?.({ cwd: input.cwd, signal: combined });
+                combined.throwIfAborted();
+                if (!result)
+                    return fallback;
+                return normalizeCatalogEntry(result, entry.provider.id);
+            }
+            catch {
+                return { ...fallback, readiness: 'unavailable' };
+            }
+        })));
+    }
+    async configureConversation(sessionId, executorId, input) {
+        const entry = this.entry(sessionId, executorId);
+        const configure = entry.provider.configureConversation;
+        if ([...entry.active].some((execution) => execution.conversationKey === input.conversationKey) ||
+            !configure)
+            throw new Error('Executor configuration is unavailable or busy');
+        if (!isExecutorConfiguration(input.configuration))
+            throw new TypeError('Invalid executor configuration');
+        await this.withActiveOperation(entry, { conversationKey: input.conversationKey }, async (signal) => {
+            await configure(input, AbortSignal.any([signal, AbortSignal.timeout(30_000)]));
+        });
+    }
+    /** Task retirement releases retained provider resources; backend refresh must not. */
+    async retireConversation(sessionId) {
+        assertSessionId(sessionId);
+        const outcomes = await Promise.allSettled([...this.registry.visible(sessionId).values()].map(async (entry) => {
+            const running = [...entry.active].filter((active) => active.conversationKey === sessionId);
+            for (const active of running)
+                active.abort.abort(new Error('Task retired'));
+            await Promise.allSettled(running.map((active) => active.settled));
+            await entry.provider.disposeConversation?.(sessionId);
+        }));
+        const failures = outcomes.flatMap((outcome) => outcome.status === 'rejected' ? [outcome.reason] : []);
+        if (failures.length)
+            throw new AggregateError(failures, 'Executor conversation cleanup failed');
+    }
     identity(sessionId, executorId) {
         return this.identityForEntry(this.entry(sessionId, executorId));
     }
@@ -122,22 +206,14 @@ export class PluginExecutorService extends Service {
     }
     async executeEntry(entry, request, options) {
         const normalizedRequest = normalizeRequest(request);
-        const abort = new AbortController();
-        const signal = options.signal ? AbortSignal.any([options.signal, abort.signal]) : abort.signal;
-        let settle;
-        const settled = new Promise((resolve) => {
-            settle = resolve;
-        });
-        const active = { abort, settled };
-        entry.active.add(active);
-        try {
+        return await this.withActiveOperation(entry, { conversationKey: normalizedRequest.conversationKey, signal: options.signal }, async (signal) => {
             if (entry.retired)
                 return cancelledResult(new ExecutorRetiredAbort(entry.provider.id));
             try {
                 const result = await entry.provider.execute(normalizedRequest, {
                     signal,
                     emit: (event) => {
-                        if (signal.aborted || entry.retired)
+                        if (entry.retired)
                             return;
                         const normalized = normalizeOutputEvent(event, entry.provider.capabilities);
                         try {
@@ -147,9 +223,29 @@ export class PluginExecutorService extends Service {
                             // A presentation observer must not change external execution.
                         }
                     },
+                    requestPermission: async (request) => {
+                        if (signal.aborted || entry.retired)
+                            return Object.freeze({ outcome: 'cancelled' });
+                        const normalized = normalizePermissionRequest(request);
+                        const result = options.onPermissionRequest
+                            ? await options.onPermissionRequest(normalized)
+                            : { outcome: 'cancelled' };
+                        if (signal.aborted || entry.retired)
+                            return Object.freeze({ outcome: 'cancelled' });
+                        return normalizePermissionResult(result, normalized);
+                    },
                 });
-                if (signal.aborted)
-                    return cancelledResult(signal.reason);
+                if (signal.aborted) {
+                    const cancelled = cancelledResult(signal.reason);
+                    const normalized = normalizeResult(result);
+                    return normalized.status === 'cancelled'
+                        ? {
+                            ...normalized,
+                            ...cancelled,
+                            ...(normalized.reason ? { reason: normalized.reason } : {}),
+                        }
+                        : cancelled;
+                }
                 return normalizeResult(result);
             }
             catch (error) {
@@ -157,6 +253,22 @@ export class PluginExecutorService extends Service {
                     return cancelledResult(signal.reason);
                 throw error;
             }
+        });
+    }
+    async withActiveOperation(entry, input, run) {
+        const abort = new AbortController();
+        const signal = input.signal ? AbortSignal.any([input.signal, abort.signal]) : abort.signal;
+        let settle;
+        const active = {
+            abort,
+            ...(input.conversationKey ? { conversationKey: input.conversationKey } : {}),
+            settled: new Promise((resolve) => {
+                settle = resolve;
+            }),
+        };
+        entry.active.add(active);
+        try {
+            return await run(signal);
         }
         finally {
             entry.active.delete(active);
@@ -213,6 +325,8 @@ function normalizeRequest(request) {
         if (!value || /[\0\r\n]/u.test(value))
             throw new TypeError(`Executor ${label} is invalid`);
     }
+    if (request.configuration !== undefined && !isExecutorConfiguration(request.configuration))
+        throw new TypeError('Executor configuration is invalid');
     if (typeof request.text !== 'string')
         throw new TypeError('Executor request text is invalid');
     if (request.runId !== undefined && (!request.runId || /[\0\r\n]/u.test(request.runId))) {
@@ -223,6 +337,9 @@ function normalizeRequest(request) {
     }
     return Object.freeze({
         ...request,
+        ...(request.configuration
+            ? { configuration: Object.freeze({ ...request.configuration }) }
+            : {}),
         ...(request.attachments ? { attachments: Object.freeze([...request.attachments]) } : {}),
         ...(request.directoryReferences
             ? { directoryReferences: Object.freeze([...request.directoryReferences]) }
@@ -269,6 +386,18 @@ function normalizeOutputEvent(event, capabilities) {
             ...(event.activityKind === undefined ? {} : { activityKind: event.activityKind }),
         });
     }
+    if (event.type === 'tool_output_delta' &&
+        capabilities?.toolActivity === true &&
+        isSafeEventId(event.toolCallId) &&
+        isSafeEventText(event.text) &&
+        (event.stream === undefined || TOOL_OUTPUT_STREAMS.some((stream) => stream === event.stream))) {
+        return Object.freeze({
+            type: event.type,
+            toolCallId: event.toolCallId,
+            text: event.text,
+            ...(event.stream === undefined ? {} : { stream: event.stream }),
+        });
+    }
     if (event.type === 'tool_progress' &&
         capabilities?.toolActivity === true &&
         isSafeEventId(event.toolCallId) &&
@@ -278,28 +407,54 @@ function normalizeOutputEvent(event, capabilities) {
     if (event.type === 'tool_result' &&
         capabilities?.toolActivity === true &&
         isSafeEventId(event.toolCallId) &&
-        isSafeEventText(event.text) &&
+        isPluginToolResultContent(event.content) &&
         (event.isError === undefined || typeof event.isError === 'boolean')) {
         return Object.freeze({
             type: event.type,
             toolCallId: event.toolCallId,
-            text: event.text,
+            content: event.content.kind === 'text'
+                ? Object.freeze({ kind: 'text', text: event.content.text })
+                : Object.freeze({
+                    kind: 'file_diff',
+                    paths: Object.freeze([...event.content.paths]),
+                    diff: event.content.diff,
+                }),
             ...(event.isError === undefined ? {} : { isError: event.isError }),
         });
     }
     throw new TypeError('Executor output event is invalid or undeclared');
 }
+function isPluginToolResultContent(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    if (value.kind === 'text')
+        return isSafeEventText(value.text);
+    return (value.kind === 'file_diff' &&
+        Array.isArray(value.paths) &&
+        value.paths.length > 0 &&
+        value.paths.length <= 64 &&
+        value.paths.every((path) => isSafeEventText(path) && path.trim().length > 0) &&
+        typeof value.diff === 'string' &&
+        value.diff.length <= 1024 * 1024 &&
+        !/[\0\r]/u.test(value.diff));
+}
 function normalizeResult(result) {
     if (!result || typeof result !== 'object')
         throw new TypeError('Executor result is invalid');
     if (result.status === 'completed' && typeof result.text === 'string') {
+        if (Buffer.byteLength(result.text, 'utf8') > MAX_EXECUTOR_COMPLETION_TEXT_BYTES)
+            throw new TypeError('Executor completion text exceeds the size limit');
         return Object.freeze({ status: result.status, text: result.text });
     }
     if (result.status === 'cancelled' &&
-        (result.reason === undefined || typeof result.reason === 'string')) {
+        (result.reason === undefined || typeof result.reason === 'string') &&
+        (result.providerStopReason === undefined || isSafeEventText(result.providerStopReason))) {
         return Object.freeze({
             status: result.status,
             ...(result.reason === undefined ? {} : { reason: result.reason }),
+            ...(result.providerStopReason === undefined
+                ? {}
+                : { providerStopReason: result.providerStopReason }),
             source: 'provider',
         });
     }
@@ -316,6 +471,47 @@ function normalizeResult(result) {
     }
     throw new TypeError('Executor result is invalid');
 }
+function normalizePermissionRequest(request) {
+    if (!request ||
+        typeof request !== 'object' ||
+        (request.kind !== undefined && request.kind !== 'permission' && request.kind !== 'question') ||
+        !isSafeEventId(request.toolCallId) ||
+        !isSafeEventText(request.title) ||
+        !request.title.trim() ||
+        !Array.isArray(request.options) ||
+        request.options.length === 0 ||
+        request.options.length > 64) {
+        throw new TypeError('Executor permission request is invalid');
+    }
+    const seen = new Set();
+    const options = request.options.map((option) => {
+        if (!option ||
+            typeof option !== 'object' ||
+            !isSafeEventId(option.optionId) ||
+            !isSafeEventText(option.name) ||
+            !option.name.trim() ||
+            seen.has(option.optionId)) {
+            throw new TypeError('Executor permission option is invalid');
+        }
+        seen.add(option.optionId);
+        return Object.freeze({ optionId: option.optionId, name: option.name });
+    });
+    return Object.freeze({
+        ...(request.kind ? { kind: request.kind } : {}),
+        toolCallId: request.toolCallId,
+        title: request.title,
+        options: Object.freeze(options),
+    });
+}
+function normalizePermissionResult(result, request) {
+    if (result?.outcome === 'cancelled')
+        return Object.freeze({ outcome: 'cancelled' });
+    if (result?.outcome === 'selected' &&
+        request.options.some((option) => option.optionId === result.optionId)) {
+        return Object.freeze({ outcome: 'selected', optionId: result.optionId });
+    }
+    throw new TypeError('Executor permission result is invalid');
+}
 function providerStateIdentity(identity) {
     return `sha256:${createHash('sha256')
         .update(JSON.stringify([

package/node_modules/@maka/runtime/dist/runtime-ledger-repair.js

@@ -19,7 +19,7 @@
 import { createHash } from 'node:crypto';
 import { deriveTurnRecords, isConversationTextMessage } from '@maka/core/session';
 import { DEFAULT_TOOL_MODE } from '@maka/core/tool-mode';
-import { buildInvocationOpenedEvent, isSessionInlineInvocation, } from '@maka/core/runtime-invocation';
+import { buildInvocationOpenedEvent, isSessionInlineInvocation, TRANSCRIPT_LEDGER_INVOCATION_ID_PREFIX, } from '@maka/core/runtime-invocation';
 import { backfillRuntimeEventsFromStoredMessages } from './runtime-event-backfill.js';
 /** How much of a legacy transcript one conversion page holds. */
 const TRANSCRIPT_CONVERSION_PAGE_MAX_MESSAGES = 256;
@@ -222,7 +222,7 @@ export function isTranscriptLedgerInvocation(invocation) {
 }
 function transcriptRunId(sessionId, turnId) {
     const digest = createHash('sha256').update(sessionId).update('\0').update(turnId).digest('hex');
-    return `transcript-${digest.slice(0, 48)}`;
+    return `${TRANSCRIPT_LEDGER_INVOCATION_ID_PREFIX}${digest.slice(0, 48)}`;
 }
 /**
  * Ids for one run's converted events, numbered in the order the converter

package/node_modules/@maka/runtime/dist/session-event-runtime-mapper.js

@@ -589,6 +589,9 @@ function completeRuntimeEvent(base, event, memory) {
         stateDelta.failureClass =
             memory.failureClass ?? failureClassFromCompleteStopReason(stopReason) ?? 'runtime_error';
     }
+    if (event.providerStopReason !== undefined) {
+        stateDelta.providerStopReason = event.providerStopReason;
+    }
     if (event.contextCompactionOutcome !== undefined) {
         stateDelta.contextCompactionOutcome = event.contextCompactionOutcome;
     }