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

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

@@ -0,0 +1,311 @@
+/*
+ * 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 { randomUUID } from 'node:crypto';
+import { AsyncEventQueue } from './async-queue.js';
+/** Converts a small plugin executor contract into Maka's existing Run event stream. */
+export class PluginExecutorBackend {
+    kind = 'plugin-executor';
+    sessionId;
+    #cwd;
+    #instructions;
+    #binding;
+    #newId;
+    #now;
+    #active = new Set();
+    #disposed = false;
+    constructor(input) {
+        this.sessionId = input.sessionId;
+        this.#cwd = input.cwd;
+        this.#instructions = input.instructions;
+        this.#binding = input.binding;
+        this.#newId = input.newId ?? randomUUID;
+        this.#now = input.now ?? Date.now;
+    }
+    async *send(input) {
+        if (this.#disposed)
+            throw new Error('Plugin executor backend is disposed');
+        const abort = new AbortController();
+        const queue = new AsyncEventQueue();
+        const messageId = this.#newId();
+        const producer = this.#produce(input, messageId, abort.signal, queue).finally(() => queue.close());
+        const active = { abort, settled: producer };
+        this.#active.add(active);
+        try {
+            for await (const event of queue) {
+                yield event;
+                queue.ackConsumed();
+            }
+            await producer;
+        }
+        finally {
+            queue.noteConsumerDetached();
+            abort.abort(new Error('Plugin executor event consumer detached'));
+            await producer.catch(() => undefined);
+            this.#active.delete(active);
+        }
+    }
+    async stop(reason) {
+        const active = [...this.#active];
+        for (const execution of active)
+            execution.abort.abort(new Error(reason));
+        await Promise.allSettled(active.map((execution) => execution.settled));
+    }
+    async respondToSandboxBoundary(_response) {
+        throw new Error('Plugin executor does not expose Maka sandbox-boundary requests');
+    }
+    async respondToUserQuestion(_response) {
+        throw new Error('Plugin executor does not expose Maka user-question requests');
+    }
+    async dispose() {
+        if (this.#disposed)
+            return;
+        this.#disposed = true;
+        await this.stop('user_stop');
+    }
+    async #produce(input, messageId, signal, queue) {
+        const turnId = input.turnId;
+        let thinkingText = '';
+        const toolUseIds = new Map();
+        let result;
+        let failure;
+        let failed = false;
+        try {
+            result = await this.#binding.execute({
+                sessionId: this.sessionId,
+                turnId,
+                ...(input.runId ? { runId: input.runId } : {}),
+                conversationKey: this.sessionId,
+                text: input.text,
+                cwd: this.#cwd,
+                ...(this.#instructions ? { instructions: this.#instructions } : {}),
+                ...(input.attachments ? { attachments: input.attachments } : {}),
+                ...(input.directoryReferences ? { directoryReferences: input.directoryReferences } : {}),
+                ...(input.quotes ? { quotes: input.quotes } : {}),
+            }, {
+                signal,
+                onEvent: (event) => {
+                    if (event.type === 'thinking_delta')
+                        thinkingText += event.text;
+                    this.#publishOutputEvent(turnId, messageId, event, toolUseIds, queue);
+                },
+            });
+        }
+        catch (error) {
+            failed = true;
+            failure = error;
+        }
+        this.#closeOptionalOutput(turnId, messageId, thinkingText, toolUseIds, queue);
+        if (failed) {
+            if (signal.aborted)
+                this.#publishCancellation(turnId, { status: 'cancelled', source: 'caller' }, queue);
+            else
+                this.#publishFailure(turnId, failure instanceof Error ? failure.message : 'External executor failed', undefined, false, queue);
+            return;
+        }
+        if (result === undefined) {
+            this.#publishFailure(turnId, 'External executor returned no terminal result', undefined, false, queue);
+            return;
+        }
+        this.#publishResult(turnId, messageId, result, queue);
+    }
+    #closeOptionalOutput(turnId, messageId, thinkingText, toolUseIds, queue) {
+        if (thinkingText) {
+            queue.push({
+                type: 'thinking_complete',
+                id: this.#newId(),
+                turnId,
+                ts: this.#now(),
+                messageId,
+                text: thinkingText,
+            });
+        }
+        for (const toolUseId of toolUseIds.values()) {
+            queue.push({
+                type: 'tool_result',
+                id: this.#newId(),
+                turnId,
+                ts: this.#now(),
+                toolUseId,
+                providerExecuted: true,
+                isError: true,
+                content: { kind: 'text', text: 'External executor ended before reporting a tool result' },
+            });
+        }
+    }
+    #publishResult(turnId, messageId, result, queue) {
+        if (result.status === 'completed') {
+            queue.push({
+                type: 'text_complete',
+                id: this.#newId(),
+                turnId,
+                ts: this.#now(),
+                messageId,
+                text: result.text,
+            });
+            queue.push({
+                type: 'complete',
+                id: this.#newId(),
+                turnId,
+                ts: this.#now(),
+                stopReason: 'end_turn',
+            });
+            return;
+        }
+        if (result.status === 'cancelled') {
+            this.#publishCancellation(turnId, result, queue);
+            return;
+        }
+        this.#publishFailure(turnId, result.message, result.code, result.recoverable ?? false, queue);
+    }
+    #publishCancellation(turnId, result, queue) {
+        const reason = cancellationEventReason(result);
+        queue.push({
+            type: 'abort',
+            id: this.#newId(),
+            turnId,
+            ts: this.#now(),
+            reason,
+        });
+        queue.push({
+            type: 'complete',
+            id: this.#newId(),
+            turnId,
+            ts: this.#now(),
+            stopReason: 'user_stop',
+        });
+    }
+    #publishOutputEvent(turnId, messageId, event, toolUseIds, queue) {
+        if (event.type === 'output_delta') {
+            if (!event.text)
+                return;
+            queue.push({
+                type: 'text_delta',
+                id: this.#newId(),
+                turnId,
+                ts: this.#now(),
+                messageId,
+                text: event.text,
+            });
+            return;
+        }
+        if (event.type === 'thinking_delta') {
+            if (!event.text)
+                return;
+            queue.push({
+                type: 'thinking_delta',
+                id: this.#newId(),
+                turnId,
+                ts: this.#now(),
+                messageId,
+                text: event.text,
+            });
+            return;
+        }
+        if (event.type === 'tool_start') {
+            const previousToolUseId = toolUseIds.get(event.toolCallId);
+            if (previousToolUseId) {
+                queue.push({
+                    type: 'tool_result',
+                    id: this.#newId(),
+                    turnId,
+                    ts: this.#now(),
+                    toolUseId: previousToolUseId,
+                    providerExecuted: true,
+                    isError: true,
+                    content: { kind: 'text', text: 'External executor reused an active tool call id' },
+                });
+            }
+            const toolUseId = this.#newId();
+            toolUseIds.set(event.toolCallId, toolUseId);
+            queue.push({
+                type: 'tool_start',
+                id: this.#newId(),
+                turnId,
+                ts: this.#now(),
+                toolUseId,
+                toolName: event.name,
+                args: event.input ?? {},
+                providerExecuted: true,
+                stepId: messageId,
+                ...(event.displayName === undefined ? {} : { displayName: event.displayName }),
+                ...(event.activityKind === undefined ? {} : { activityKind: event.activityKind }),
+            });
+            return;
+        }
+        const toolUseId = toolUseIds.get(event.toolCallId);
+        if (!toolUseId)
+            return;
+        if (event.type === 'tool_progress') {
+            if (!event.text)
+                return;
+            queue.push({
+                type: 'tool_progress',
+                id: this.#newId(),
+                turnId,
+                ts: this.#now(),
+                toolUseId,
+                chunk: event.text,
+            });
+            return;
+        }
+        toolUseIds.delete(event.toolCallId);
+        queue.push({
+            type: 'tool_result',
+            id: this.#newId(),
+            turnId,
+            ts: this.#now(),
+            toolUseId,
+            providerExecuted: true,
+            isError: event.isError ?? false,
+            content: { kind: 'text', text: event.text },
+        });
+    }
+    #publishFailure(turnId, message, code, recoverable, queue) {
+        queue.push({
+            type: 'error',
+            id: this.#newId(),
+            turnId,
+            ts: this.#now(),
+            recoverable,
+            ...(code ? { code, reason: code } : {}),
+            message: boundedMessage(message),
+        });
+        queue.push({
+            type: 'complete',
+            id: this.#newId(),
+            turnId,
+            ts: this.#now(),
+            stopReason: 'error',
+        });
+    }
+}
+function boundedMessage(value) {
+    if (value.length <= 8_192)
+        return value;
+    return `${value.slice(0, 8_191)}…`;
+}
+function cancellationEventReason(result) {
+    if (result.reason === 'redirect')
+        return 'redirect';
+    if (result.reason === 'timeout')
+        return 'timeout';
+    if (result.source === 'executor_retired')
+        return 'crash';
+    return 'user_stop';
+}

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

@@ -0,0 +1,344 @@
+/*
+ * 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 { createHash } from 'node:crypto';
+import { TOOL_ACTIVITY_KINDS } 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';
+class ExecutorRetiredAbort extends Error {
+    constructor(executorId) {
+        super(`Executor was retired: ${executorId}`);
+        this.name = 'ExecutorRetiredAbort';
+    }
+}
+/**
+ * Scoped black-box execution registry.
+ *
+ * The service owns only registration, visibility, cancellation, and result
+ * validation. Protocol processes, credentials, external conversation ids, and
+ * tools remain private to the contributing plugin.
+ */
+export class PluginExecutorService extends Service {
+    registry = new PluginScopeRegistry();
+    onChanged;
+    constructor(ctx, options = {}) {
+        super(ctx, 'executors');
+        this.onChanged = options.onChanged;
+    }
+    register(provider) {
+        validateProvider(provider);
+        const identity = pluginIdentity(this.ctx);
+        return registerPluginContribution(this.ctx, `executors.register(${provider.id})`, () => {
+            const rootId = identity.scopeId;
+            const existing = this.registry.get(rootId, provider.id);
+            if (existing && existing.entryId !== identity.entryId) {
+                throw new MakaPluginRuntimeError('activation_failed', `Executor is already registered in this scope: ${provider.id}`);
+            }
+            const capabilities = normalizeCapabilities(provider.capabilities);
+            const registeredProvider = Object.freeze({
+                id: provider.id,
+                ...(provider.displayName === undefined ? {} : { displayName: provider.displayName }),
+                capabilities,
+                execute: provider.execute.bind(provider),
+            });
+            const entry = {
+                ...identity,
+                provider: registeredProvider,
+                token: Symbol(provider.id),
+                active: new Set(),
+                retired: false,
+            };
+            return this.registry.publish(rootId, provider.id, entry, {
+                ...(this.onChanged ? { onChanged: this.onChanged } : {}),
+                onRetired: async (retired) => {
+                    for (const execution of retired.active) {
+                        execution.abort.abort(new ExecutorRetiredAbort(retired.provider.id));
+                    }
+                    await Promise.allSettled([...retired.active].map((execution) => execution.settled));
+                },
+            });
+        });
+    }
+    list(sessionId) {
+        assertSessionId(sessionId);
+        return Object.freeze([...this.registry.visible(sessionId).values()]
+            .sort((left, right) => left.provider.id.localeCompare(right.provider.id))
+            .map(({ provider, token: _token, active: _active, retired: _retired, ...identity }) => Object.freeze({
+            ...identity,
+            id: provider.id,
+            displayName: provider.displayName?.trim() || provider.id,
+            capabilities: normalizeCapabilities(provider.capabilities),
+        })));
+    }
+    inspect(rootId) {
+        const seen = new Set();
+        return Object.freeze([...this.registry.entries(rootId)]
+            .filter((entry) => !seen.has(entry) && Boolean(seen.add(entry)))
+            .sort((left, right) => left.provider.id.localeCompare(right.provider.id))
+            .map(({ provider, token: _token, active: _active, retired: _retired, ...identity }) => Object.freeze({
+            ...identity,
+            id: provider.id,
+            displayName: provider.displayName?.trim() || provider.id,
+            capabilities: normalizeCapabilities(provider.capabilities),
+        })));
+    }
+    identity(sessionId, executorId) {
+        return this.identityForEntry(this.entry(sessionId, executorId));
+    }
+    bind(sessionId, executorId) {
+        const entry = this.entry(sessionId, executorId);
+        const identity = this.identityForEntry(entry);
+        return Object.freeze({
+            identity,
+            providerStateIdentity: providerStateIdentity(identity),
+            execute: (request, options = {}) => {
+                if (request.sessionId !== sessionId) {
+                    throw new Error('Executor binding cannot cross Session scope');
+                }
+                return this.executeEntry(entry, request, options);
+            },
+        });
+    }
+    async execute(executorId, request, options = {}) {
+        const normalizedRequest = normalizeRequest(request);
+        return this.executeEntry(this.entry(normalizedRequest.sessionId, executorId), normalizedRequest, options);
+    }
+    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 {
+            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)
+                            return;
+                        const normalized = normalizeOutputEvent(event, entry.provider.capabilities);
+                        try {
+                            options.onEvent?.(normalized);
+                        }
+                        catch {
+                            // A presentation observer must not change external execution.
+                        }
+                    },
+                });
+                if (signal.aborted)
+                    return cancelledResult(signal.reason);
+                return normalizeResult(result);
+            }
+            catch (error) {
+                if (signal.aborted)
+                    return cancelledResult(signal.reason);
+                throw error;
+            }
+        }
+        finally {
+            entry.active.delete(active);
+            settle();
+        }
+    }
+    entry(sessionId, executorId) {
+        assertSessionId(sessionId);
+        if (!isExecutorId(executorId))
+            throw new TypeError('Executor id is invalid');
+        const entry = this.registry.visible(sessionId).get(executorId);
+        if (!entry || entry.retired)
+            throw new Error(`Executor is unavailable: ${executorId}`);
+        return entry;
+    }
+    identityForEntry(entry) {
+        return Object.freeze({
+            entryId: entry.entryId,
+            scopeId: entry.scopeId,
+            extensionId: entry.extensionId,
+            generation: entry.generation,
+            id: entry.provider.id,
+            displayName: entry.provider.displayName?.trim() || entry.provider.id,
+            capabilities: normalizeCapabilities(entry.provider.capabilities),
+        });
+    }
+}
+function validateProvider(provider) {
+    if (!provider || typeof provider !== 'object')
+        throw new TypeError('Executor provider is required');
+    if (!isExecutorId(provider.id))
+        throw new TypeError('Executor id is invalid');
+    if (typeof provider.execute !== 'function') {
+        throw new TypeError(`Executor implementation is invalid: ${provider.id}`);
+    }
+    if (provider.displayName !== undefined &&
+        (typeof provider.displayName !== 'string' || !provider.displayName.trim())) {
+        throw new TypeError(`Executor display name is invalid: ${provider.id}`);
+    }
+}
+function assertSessionId(value) {
+    if (!value || /[\0\r\n]/u.test(value))
+        throw new TypeError('Session id is invalid');
+}
+function normalizeRequest(request) {
+    if (!request || typeof request !== 'object')
+        throw new TypeError('Executor request is required');
+    assertSessionId(request.sessionId);
+    for (const [label, value] of [
+        ['turnId', request.turnId],
+        ['conversationKey', request.conversationKey],
+        ['cwd', request.cwd],
+    ]) {
+        if (!value || /[\0\r\n]/u.test(value))
+            throw new TypeError(`Executor ${label} 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))) {
+        throw new TypeError('Executor runId is invalid');
+    }
+    if (request.instructions !== undefined && typeof request.instructions !== 'string') {
+        throw new TypeError('Executor instructions are invalid');
+    }
+    return Object.freeze({
+        ...request,
+        ...(request.attachments ? { attachments: Object.freeze([...request.attachments]) } : {}),
+        ...(request.directoryReferences
+            ? { directoryReferences: Object.freeze([...request.directoryReferences]) }
+            : {}),
+        ...(request.quotes ? { quotes: Object.freeze([...request.quotes]) } : {}),
+    });
+}
+function normalizeCapabilities(value) {
+    if (value !== undefined &&
+        (!value ||
+            typeof value !== 'object' ||
+            (value.thinking !== undefined && typeof value.thinking !== 'boolean') ||
+            (value.toolActivity !== undefined && typeof value.toolActivity !== 'boolean'))) {
+        throw new TypeError('Executor capabilities are invalid');
+    }
+    return Object.freeze({
+        thinking: value?.thinking === true,
+        toolActivity: value?.toolActivity === true,
+    });
+}
+function normalizeOutputEvent(event, capabilities) {
+    if (!event || typeof event !== 'object')
+        throw new TypeError('Executor output event is invalid');
+    if (event.type === 'output_delta' && typeof event.text === 'string') {
+        return Object.freeze({ type: event.type, text: event.text });
+    }
+    if (event.type === 'thinking_delta' &&
+        capabilities?.thinking === true &&
+        isSafeEventText(event.text)) {
+        return Object.freeze({ type: event.type, text: event.text });
+    }
+    if (event.type === 'tool_start' &&
+        capabilities?.toolActivity === true &&
+        isSafeEventId(event.toolCallId) &&
+        isSafeEventId(event.name) &&
+        (event.displayName === undefined || isSafeEventText(event.displayName)) &&
+        (event.activityKind === undefined || TOOL_ACTIVITY_KINDS.includes(event.activityKind))) {
+        return Object.freeze({
+            type: event.type,
+            toolCallId: event.toolCallId,
+            name: event.name,
+            ...(event.input === undefined ? {} : { input: structuredClone(event.input) }),
+            ...(event.displayName === undefined ? {} : { displayName: event.displayName }),
+            ...(event.activityKind === undefined ? {} : { activityKind: event.activityKind }),
+        });
+    }
+    if (event.type === 'tool_progress' &&
+        capabilities?.toolActivity === true &&
+        isSafeEventId(event.toolCallId) &&
+        isSafeEventText(event.text)) {
+        return Object.freeze({ type: event.type, toolCallId: event.toolCallId, text: event.text });
+    }
+    if (event.type === 'tool_result' &&
+        capabilities?.toolActivity === true &&
+        isSafeEventId(event.toolCallId) &&
+        isSafeEventText(event.text) &&
+        (event.isError === undefined || typeof event.isError === 'boolean')) {
+        return Object.freeze({
+            type: event.type,
+            toolCallId: event.toolCallId,
+            text: event.text,
+            ...(event.isError === undefined ? {} : { isError: event.isError }),
+        });
+    }
+    throw new TypeError('Executor output event is invalid or undeclared');
+}
+function normalizeResult(result) {
+    if (!result || typeof result !== 'object')
+        throw new TypeError('Executor result is invalid');
+    if (result.status === 'completed' && typeof result.text === 'string') {
+        return Object.freeze({ status: result.status, text: result.text });
+    }
+    if (result.status === 'cancelled' &&
+        (result.reason === undefined || typeof result.reason === 'string')) {
+        return Object.freeze({
+            status: result.status,
+            ...(result.reason === undefined ? {} : { reason: result.reason }),
+            source: 'provider',
+        });
+    }
+    if (result.status === 'failed' &&
+        typeof result.message === 'string' &&
+        (result.code === undefined || typeof result.code === 'string') &&
+        (result.recoverable === undefined || typeof result.recoverable === 'boolean')) {
+        return Object.freeze({
+            status: result.status,
+            message: result.message,
+            ...(result.code === undefined ? {} : { code: result.code }),
+            ...(result.recoverable === undefined ? {} : { recoverable: result.recoverable }),
+        });
+    }
+    throw new TypeError('Executor result is invalid');
+}
+function providerStateIdentity(identity) {
+    return `sha256:${createHash('sha256')
+        .update(JSON.stringify([
+        'plugin-executor.v1',
+        identity.id,
+        identity.extensionId,
+        identity.entryId,
+        identity.generation,
+    ]))
+        .digest('hex')}`;
+}
+function cancelledResult(reason) {
+    const source = reason instanceof ExecutorRetiredAbort ? 'executor_retired' : 'caller';
+    const message = reason instanceof Error ? reason.message : typeof reason === 'string' ? reason : undefined;
+    return Object.freeze({
+        status: 'cancelled',
+        source,
+        ...(message ? { reason: message } : {}),
+    });
+}
+function isSafeEventId(value) {
+    return (typeof value === 'string' && value.length > 0 && value.length <= 256 && !/[\0\r\n]/u.test(value));
+}
+function isSafeEventText(value) {
+    return typeof value === 'string' && value.length <= 8_192 && !/[\0\r]/u.test(value);
+}

package/node_modules/@maka/runtime/dist/provider-error-classification.js

@@ -85,6 +85,7 @@ const PROVIDER_FAILURE_FIELD_MAX_BYTES = 256;
 const MAX_SAFE_TIMER_DELAY_MS = 2_147_483_647;
 const OPENAI_RESPONSES_WEBSOCKET_TRANSPORT_ERROR = 'OPENAI_RESPONSES_WEBSOCKET_TRANSPORT_ERROR';
 const RUNTIME_RETRYABLE_ERROR_CODES = new Set([
+    'MODEL_STREAM_TIMEOUT',
     OPENAI_RESPONSES_WEBSOCKET_TRANSPORT_ERROR,
     'OPENAI_RESPONSES_CONTINUATION_UNAVAILABLE',
 ]);
@@ -178,7 +179,8 @@ function retryMetadataFromFacts(facts, errorClass = classifyProviderFacts(facts)
             return { retryable: false };
         return { retryable: true, retryAfterMs };
     }
-    const retryable = errorClass === 'network' ||
+    const retryable = errorClass === 'stream_truncated' ||
+        errorClass === 'network' ||
         errorClass === 'provider_unavailable' ||
         status === 408 ||
         status === 409 ||
@@ -606,6 +608,10 @@ function classifyProviderFacts(facts) {
     const normalizedCode = code.toLowerCase();
     if (code === OPENAI_RESPONSES_WEBSOCKET_TRANSPORT_ERROR)
         return 'network';
+    if (code === 'MODEL_STREAM_TIMEOUT')
+        return 'timeout';
+    if (structuredCodes.includes('gateway_stream_terminated'))
+        return 'stream_truncated';
     if (PROVIDER_CAPACITY_CODES.has(normalizedCode) ||
         structuredCodes.some((c) => PROVIDER_CAPACITY_CODES.has(c))) {
         return 'provider_capacity';