@armoriq/sdk-dev 0.6.8 → 0.7.0

package/dist/integrations/strands.js

@@ -31,6 +31,9 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ArmorIQStrandsPlugin = exports.ArmorIQStrands = void 0;
+const tool_push_1 = require("../tool_push");
+const tool_registry_1 = require("../tool_registry");
+const tool_name_1 = require("../tool_name");
 const STRANDS_PACKAGE = '@strands-agents/sdk';
 const EVENT_NAMES = [
     'AfterModelCallEvent',
@@ -50,6 +53,8 @@ function pickEventClasses(mod) {
         AfterModelCallEvent: src.AfterModelCallEvent,
         BeforeToolCallEvent: src.BeforeToolCallEvent,
         AfterToolCallEvent: src.AfterToolCallEvent,
+        AfterInvocationEvent: typeof src.AfterInvocationEvent === 'function' ? src.AfterInvocationEvent : undefined,
+        BeforeModelCallEvent: typeof src.BeforeModelCallEvent === 'function' ? src.BeforeModelCallEvent : undefined,
     };
 }
 /** Load the event classes without a static import, so strands stays optional. */
@@ -110,16 +115,23 @@ class ArmorIQStrands {
     async toolNameParser() {
         if (this.customParser)
             return this.customParser;
-        const toolMap = (await this.bootstrap()).toolMap ?? {};
+        let toolMap = {};
+        try {
+            toolMap = (await this.bootstrap()).toolMap ?? {};
+        }
+        catch {
+            // A bootstrap outage must not prevent model-only work. Actual tool
+            // execution still passes through the session's fail-closed check.
+            console.warn('[armoriq] strands bootstrap unavailable; using safe tool-name fallback');
+        }
         const defaultMcp = this.defaultMcpName ?? 'unknown';
         return (toolName) => {
             const mcp = toolMap[toolName];
             if (mcp)
                 return { mcp, action: toolName };
-            if (toolName.includes('__')) {
-                const [prefix, ...rest] = toolName.split('__');
-                return { mcp: prefix, action: rest.join('__') };
-            }
+            const split = (0, tool_name_1.splitPrefixedToolName)(toolName);
+            if (split)
+                return split;
             return { mcp: defaultMcp, action: toolName };
         };
     }
@@ -151,11 +163,19 @@ class ArmorIQStrandsPlugin {
     parser;
     session;
     planStarted = false;
+    pendingPlanCapture;
     eventClasses;
     // toolUseIds we cancelled in beforeToolCall. AfterToolCallEvent still fires
     // for a cancelled tool and carries nothing that distinguishes it, so this is
     // the only way to know the tool never actually ran.
     cancelledToolUseIds = new Set();
+    hadToolError = false;
+    pendingTerminalStatus;
+    /** Framework-native request state. A plugin may serve concurrent streams. */
+    invocationRequests = new Map();
+    closedInvocationStates = new WeakSet();
+    closed = false;
+    legacyInvocationState;
     constructor(args) {
         this.factory = args.factory;
         this.scope = args.scope;
@@ -165,6 +185,17 @@ class ArmorIQStrandsPlugin {
         this.parser = args.parser;
         this.eventClasses = args.eventClasses ?? args.factory?.eventClasses;
     }
+    frameworkMcpOperation(toolName, itemOrdinal, toolCallId) {
+        return {
+            category: 'mcp',
+            name: 'mcp.execute',
+            toolType: 'mcp',
+            toolName,
+            callId: toolCallId,
+            mcpServer: this.parser(toolName).mcp,
+            planItemOrdinal: itemOrdinal,
+        };
+    }
     /** Strands Plugin entrypoint: register our hooks on the agent. */
     async initAgent(agent) {
         if (!this.eventClasses)
@@ -173,6 +204,10 @@ class ArmorIQStrandsPlugin {
     }
     /** Wire the AfterModelCall + BeforeToolCall hooks onto a Strands agent. */
     register(agent) {
+        (0, tool_registry_1.registerForClient)(this.factory.client, ...(() => {
+            const d = (0, tool_registry_1.declarationsFromStrandsAgent)(agent);
+            return [d.tools, d.servers];
+        })());
         const add = (agent.addHook ?? agent.hooks?.addCallback)?.bind(agent.addHook ? agent : agent.hooks);
         if (!add) {
             throw new Error('ArmorIQStrands: agent has no addHook/hooks.addCallback');
@@ -184,6 +219,131 @@ class ArmorIQStrandsPlugin {
         add(events.AfterModelCallEvent, (e) => this.onAfterModelCall(e));
         add(events.BeforeToolCallEvent, (e) => this.beforeToolCall(e));
         add(events.AfterToolCallEvent, (e) => this.onAfterToolCall(e));
+        // Strands guarantees BeforeModelCallEvent pairs with AfterModelCallEvent,
+        // so the model span opens here (before inference) and is only ever ended
+        // by onAfterModelCall — including the error path where stopData is
+        // absent. Without it (older strands, or a host-injected partial
+        // eventClasses map), onAfterModelCall falls back to opening the span
+        // itself, same as before this fix.
+        if (events.BeforeModelCallEvent) {
+            add(events.BeforeModelCallEvent, (e) => this.onBeforeModelCall(e));
+        }
+        // Strands guarantees this terminal hook runs after both successful and
+        // failed invocations. It is the bounded final-flush path when application
+        // code disconnects before it can call plugin.close() itself.
+        if (events.AfterInvocationEvent) {
+            add(events.AfterInvocationEvent, (e) => this.onAfterInvocation(e));
+        }
+    }
+    /** End and ship the request-owned plan session without closing the shared client. */
+    async close(status = 'ok') {
+        if (this.closed)
+            return;
+        this.closed = true;
+        await this.closeRequest(undefined, status);
+    }
+    isClosedInvocation(event) {
+        const state = event?.invocationState;
+        return (this.closed ||
+            (!!state && typeof state === 'object' && this.closedInvocationStates.has(state)));
+    }
+    requestFor(event) {
+        const invocationState = event?.invocationState;
+        if (!invocationState ||
+            (typeof invocationState !== 'object' && typeof invocationState !== 'function')) {
+            return undefined;
+        }
+        let request = this.invocationRequests.get(invocationState);
+        if (request)
+            return request;
+        // Keep direct/legacy callers working: existing consumers may preload a
+        // session before the first real framework event is delivered.
+        if (!this.legacyInvocationState &&
+            (this.session || this.planStarted || this.pendingPlanCapture)) {
+            this.legacyInvocationState = invocationState;
+            request = {
+                session: this.session,
+                planStarted: this.planStarted,
+                pendingPlanCapture: this.pendingPlanCapture,
+                cancelledToolUseIds: this.cancelledToolUseIds,
+                hadToolError: this.hadToolError,
+                pendingTerminalStatus: this.pendingTerminalStatus,
+            };
+        }
+        else {
+            request = { planStarted: false, cancelledToolUseIds: new Set(), hadToolError: false };
+        }
+        this.invocationRequests.set(invocationState, request);
+        return request;
+    }
+    async closeRequest(request, status, taskOutcome) {
+        // A public `plugin.close()` has no framework event to pass back, but it
+        // must still finalize the request state that a prior event adopted as the
+        // legacy request. Otherwise its root output is silently discarded.
+        const legacyRequest = !request && this.legacyInvocationState !== undefined
+            ? this.invocationRequests.get(this.legacyInvocationState)
+            : undefined;
+        const activeRequest = request ?? legacyRequest;
+        const session = activeRequest?.session ?? this.session;
+        const pendingPlanCapture = activeRequest?.pendingPlanCapture ?? this.pendingPlanCapture;
+        const isLegacyRequest = !!activeRequest &&
+            this.legacyInvocationState !== undefined &&
+            this.invocationRequests.get(this.legacyInvocationState) === activeRequest;
+        if (activeRequest) {
+            activeRequest.session = undefined;
+            activeRequest.planStarted = false;
+            activeRequest.cancelledToolUseIds.clear();
+            activeRequest.hadToolError = false;
+            activeRequest.pendingTerminalStatus = undefined;
+            if (isLegacyRequest) {
+                this.invocationRequests.delete(this.legacyInvocationState);
+                this.legacyInvocationState = undefined;
+                this.session = undefined;
+                this.planStarted = false;
+                this.pendingPlanCapture = undefined;
+            }
+        }
+        else {
+            this.session = undefined;
+            this.planStarted = false;
+            this.cancelledToolUseIds.clear();
+            this.hadToolError = false;
+            this.pendingTerminalStatus = undefined;
+            // A caller-owned close wins any in-flight legacy event. Its completion
+            // must not resurrect the detached request state.
+            this.legacyInvocationState = undefined;
+        }
+        if (session && pendingPlanCapture && pendingPlanCapture.session === session) {
+            try {
+                await pendingPlanCapture.promise;
+            }
+            catch {
+                // Plan capture failures are handled by the lifecycle hook; teardown remains best-effort.
+            }
+        }
+        const telemetryState = activeRequest ?? this;
+        const error = status === 'ok' ? undefined : new Error('terminal lifecycle');
+        const unfinishedToolOutcome = status === 'error' ? 'error' : status === 'timeout' ? 'timeout' :
+            status === 'disconnected' ? 'disconnected' : 'cancelled';
+        await Promise.all([
+            ...[...(telemetryState.toolSpans?.values?.() ?? [])].filter(Boolean).map((span) => session?.otelSession?.endTool(span, { outcome: unfinishedToolOutcome, error })),
+            ...(telemetryState.modelSpan
+                ? [session?.otelSession?.endModel(telemetryState.modelSpan, {}, error, status)]
+                : []),
+        ]);
+        telemetryState.toolSpans?.clear?.();
+        telemetryState.modelSpan = undefined;
+        telemetryState.invocationFailed = false;
+        const rootOutput = telemetryState.finalOutput;
+        telemetryState.finalOutput = undefined;
+        if (session) {
+            if (rootOutput === undefined && taskOutcome === undefined)
+                await session.close(status);
+            else if (rootOutput === undefined)
+                await session.close(status, taskOutcome);
+            else
+                await session.close(status, taskOutcome, { output: rootOutput });
+        }
     }
     emit(kind, payload) {
         if (!this.onEvent)
@@ -195,7 +355,22 @@ class ArmorIQStrandsPlugin {
             console.warn(`[armoriq] onEvent(${kind}) callback failed: ${exc.message}`);
         }
     }
-    ensureSession() {
+    ensureSession(request) {
+        if (request) {
+            if (!request.session) {
+                request.session = this.scope.startSession({
+                    mode: this.factory.mode,
+                    validitySeconds: this.factory.validitySeconds,
+                    toolNameParser: this.parser,
+                    defaultMcpName: this.factory.defaultMcpName,
+                });
+                if (this.legacyInvocationState !== undefined &&
+                    this.invocationRequests.get(this.legacyInvocationState) === request) {
+                    this.session = request.session;
+                }
+            }
+            return request.session;
+        }
         if (!this.session) {
             this.session = this.scope.startSession({
                 mode: this.factory.mode,
@@ -206,11 +381,47 @@ class ArmorIQStrandsPlugin {
         }
         return this.session;
     }
-    async capturePlan(toolCalls) {
+    async capturePlan(toolCalls, request) {
         if (!toolCalls.length)
             return;
-        await this.ensureSession().startPlan(toolCalls, this.goal);
-        this.planStarted = true;
+        const session = this.ensureSession(request);
+        const pendingPlanCapture = { session, promise: session.startPlan(toolCalls, this.goal) };
+        if (request) {
+            request.pendingPlanCapture = pendingPlanCapture;
+            if (this.legacyInvocationState !== undefined &&
+                this.invocationRequests.get(this.legacyInvocationState) === request) {
+                this.pendingPlanCapture = pendingPlanCapture;
+            }
+        }
+        else
+            this.pendingPlanCapture = pendingPlanCapture;
+        try {
+            await pendingPlanCapture.promise;
+            if (request) {
+                if (request.session === session) {
+                    request.planStarted = true;
+                    if (this.legacyInvocationState !== undefined &&
+                        this.invocationRequests.get(this.legacyInvocationState) === request) {
+                        this.planStarted = true;
+                    }
+                }
+            }
+            else if (this.session === session)
+                this.planStarted = true;
+        }
+        finally {
+            if (request) {
+                if (request.pendingPlanCapture === pendingPlanCapture) {
+                    request.pendingPlanCapture = undefined;
+                    if (this.legacyInvocationState !== undefined &&
+                        this.invocationRequests.get(this.legacyInvocationState) === request) {
+                        this.pendingPlanCapture = undefined;
+                    }
+                }
+            }
+            else if (this.pendingPlanCapture === pendingPlanCapture)
+                this.pendingPlanCapture = undefined;
+        }
     }
     /** Extract {name, args} for each toolUse block in a Strands model message. */
     static toolCallsFromMessage(message) {
@@ -228,17 +439,107 @@ class ArmorIQStrandsPlugin {
         }
         return calls;
     }
+    /**
+     * Opens the model span before inference begins, so its recorded duration
+     * reflects real model latency rather than the ~0ms window between
+     * AfterModelCallEvent firing and this plugin ending the span in the same
+     * callback. `onAfterModelCall` always ends whatever span this opened —
+     * including when the paired event carries an error and no `stopData`.
+     */
+    /** Strands re-reads its tool registry before every model call; mirror it into the inventory. */
+    refreshDeclarations(agent) {
+        if (!agent)
+            return;
+        try {
+            const d = (0, tool_registry_1.declarationsFromStrandsAgent)(agent);
+            (0, tool_registry_1.registerForClient)(this.factory.client, d.tools, d.servers);
+        }
+        catch {
+            /* inventory problems never stop an agent */
+        }
+        (0, tool_push_1.noteModelCall)(this.factory.client);
+    }
+    async onBeforeModelCall(event) {
+        if (this.isClosedInvocation(event))
+            return;
+        this.refreshDeclarations(event?.agent);
+        const request = this.requestFor(event);
+        const telemetryState = request ?? this;
+        try {
+            const session = this.ensureSession(request);
+            const otel = session.otelSession;
+            // Strands does not consistently expose the original prompt in its model
+            // hooks. The caller supplied goal is the only stable request input;
+            // retain an explicit unavailable marker rather than inventing a prompt.
+            const input = this.goal === undefined
+                ? { availability: 'unavailable', reason: 'framework_goal_not_provided' }
+                : this.goal;
+            if (typeof otel?.beginRoot === 'function')
+                await otel.beginRoot({ input });
+            telemetryState.modelSpan = typeof otel?.beginModel === 'function'
+                ? await otel.beginModel(String(event?.model?.modelId ?? event?.model?.model ?? 'unknown'), { input })
+                : undefined;
+        }
+        catch (exc) {
+            console.warn(`[armoriq] strands model span start (before model) failed: ${exc.message}`);
+        }
+    }
     async onAfterModelCall(event) {
+        if (this.isClosedInvocation(event))
+            return;
+        const request = this.requestFor(event);
+        const telemetryState = request ?? this;
+        let modelError = event?.error;
+        let session;
         try {
+            session = this.ensureSession(request);
+            const otel = session.otelSession;
+            const input = this.goal === undefined
+                ? { availability: 'unavailable', reason: 'framework_goal_not_provided' }
+                : this.goal;
+            // Fallback for hosts whose eventClasses omit BeforeModelCallEvent (older
+            // strands, or a host-injected partial map): open the span here so a
+            // model call is still captured, even though its duration is then ~0ms.
+            if (telemetryState.modelSpan === undefined) {
+                if (typeof otel?.beginRoot === 'function')
+                    await otel.beginRoot({ input });
+                telemetryState.modelSpan = typeof otel?.beginModel === 'function'
+                    ? await otel.beginModel(String(event?.model?.modelId ?? event?.model?.model ?? 'unknown'), { input })
+                    : undefined;
+            }
             const stopData = event?.stopData;
-            if (!stopData)
-                return; // model errored; nothing to capture this turn
+            if (!stopData) {
+                // Model errored (or was cancelled) this turn: no message to mint an
+                // intent plan from. The AfterInvocationEvent terminal hook carries no
+                // error field of its own (see terminalStatus()), so remember this
+                // here — it is how the terminal hook learns the invocation failed.
+                telemetryState.invocationFailed = true;
+                return;
+            }
+            telemetryState.invocationFailed = false;
+            telemetryState.finalOutput = stopData.message;
             const toolCalls = ArmorIQStrandsPlugin.toolCallsFromMessage(stopData?.message);
-            await this.capturePlan(toolCalls);
+            const ordinals = telemetryState.toolOrdinals ?? new Map();
+            telemetryState.toolOrdinals = ordinals;
+            let ordinal = 0;
+            for (const content of stopData?.message?.content ?? []) {
+                const toolUse = content?.toolUse ?? content;
+                if (typeof toolUse?.toolUseId === 'string') {
+                    ordinals.set(toolUse.toolUseId, ordinal);
+                    ordinal += 1;
+                }
+            }
+            await this.capturePlan(toolCalls, request);
         }
         catch (exc) {
+            modelError = modelError ?? exc;
             console.warn(`[armoriq] strands plan capture (after model) failed: ${exc.message}`);
         }
+        finally {
+            const span = telemetryState.modelSpan;
+            telemetryState.modelSpan = undefined;
+            await session?.otelSession?.endModel(span ?? { span: null, name: 'gen_ai.chat' }, { ...(event?.stopData?.stopReason ? { 'gen_ai.response.finish_reasons': [event.stopData.stopReason] } : {}) }, modelError, undefined, event?.stopData?.message === undefined ? undefined : { output: event.stopData.message });
+        }
     }
     /**
      * Key a tool call so beforeToolCall can tell onAfterToolCall "this one never
@@ -249,26 +550,63 @@ class ArmorIQStrandsPlugin {
         return toolUse?.toolUseId ?? toolUse?.name ?? '';
     }
     /** Cancel the tool and remember that we did, so we never audit it as run. */
-    cancelTool(event, toolUse, message) {
+    cancelTool(event, toolUse, message, request) {
         event.cancel = message;
         const key = ArmorIQStrandsPlugin.cancelKey(toolUse);
         if (key)
-            this.cancelledToolUseIds.add(key);
+            (request?.cancelledToolUseIds ?? this.cancelledToolUseIds).add(key);
     }
     async beforeToolCall(event) {
+        if (this.isClosedInvocation(event)) {
+            event.cancel = 'ArmorIQ request is closed';
+            return;
+        }
+        const request = this.requestFor(event);
+        const telemetryState = request ?? this;
         const toolUse = event?.toolUse ?? event?.tool_use ?? {};
         const toolName = toolUse.name ?? '';
         const args = toolUse.input ?? {};
+        const itemOrdinal = telemetryState.toolOrdinals?.get(toolUse.toolUseId);
+        let policySession;
+        let policySpan;
         try {
-            if (!this.planStarted) {
+            if (!(request?.planStarted ?? this.planStarted)) {
                 // Fail-safe: AfterModelCall normally mints the plan first. If it didn't,
                 // mint from the tool actually being called — never the agent's full tool set.
-                await this.capturePlan([{ name: toolName, args }]);
+                await this.capturePlan([{ name: toolName, args }], request);
+            }
+            const session = this.ensureSession(request);
+            policySession = session;
+            policySpan = await session.otelSession?.beginPolicy({
+                toolName, itemOrdinal, toolCallId: toolUse.toolUseId, arguments: args,
+            });
+            const decision = await session.check(toolName, args, this.userEmail, { emitOtel: false });
+            const policy = decision;
+            await session.otelSession?.endPolicy(policySpan ?? { span: null, name: 'armoriq.policy.evaluate' }, {
+                decision: decision.allowed ? 'allow' : decision.action === 'hold' ? 'hold' : 'block',
+                policyName: decision.matchedPolicy,
+                ...(policy.policyId ? { policyId: policy.policyId } : {}),
+                policyVersion: policy.policyVersion,
+                policySource: policy.policySource,
+                policyReasonCode: decision.reason,
+                defaultAction: policy.defaultAction,
+                matchedRuleId: policy.matchedRuleId,
+            });
+            if (decision.allowed) {
+                const key = ArmorIQStrandsPlugin.cancelKey(toolUse);
+                if (key) {
+                    const toolSpans = telemetryState.toolSpans ?? new Map();
+                    telemetryState.toolSpans = toolSpans;
+                    toolSpans.set(key, await session.otelSession?.beginTool({
+                        toolName,
+                        itemOrdinal,
+                        toolCallId: toolUse.toolUseId,
+                        arguments: args,
+                        operation: this.frameworkMcpOperation(toolName, itemOrdinal, toolUse.toolUseId),
+                    }));
+                }
+                return;
             }
-            const session = this.ensureSession();
-            const decision = await session.check(toolName, args, this.userEmail);
-            if (decision.allowed)
-                return; // explicit allow → tool runs
             if (decision.action === 'hold') {
                 this.emit('hold', {
                     tool: toolName,
@@ -282,6 +620,18 @@ class ArmorIQStrandsPlugin {
                 });
                 if (outcome === 'approved') {
                     this.emit('approved', { tool: toolName, delegationId: decision.delegationId });
+                    const key = ArmorIQStrandsPlugin.cancelKey(toolUse);
+                    if (key) {
+                        const toolSpans = telemetryState.toolSpans ?? new Map();
+                        telemetryState.toolSpans = toolSpans;
+                        toolSpans.set(key, await session.otelSession?.beginTool({
+                            toolName,
+                            itemOrdinal,
+                            toolCallId: toolUse.toolUseId,
+                            arguments: args,
+                            operation: this.frameworkMcpOperation(toolName, itemOrdinal, toolUse.toolUseId),
+                        }));
+                    }
                     return; // approved → do NOT cancel; the tool runs
                 }
                 this.emit(outcome, {
@@ -289,19 +639,20 @@ class ArmorIQStrandsPlugin {
                     delegationId: decision.delegationId,
                     reason: decision.reason,
                 });
-                this.cancelTool(event, toolUse, `ArmorIQ hold ${outcome}: ${decision.reason ?? 'approval required'}`);
+                this.cancelTool(event, toolUse, `ArmorIQ hold ${outcome}: ${decision.reason ?? 'approval required'}`, request);
                 return;
             }
             // block (or any other non-allow decision)
             const reason = decision.reason ?? 'blocked by policy';
             this.emit('block', { tool: toolName, reason });
-            this.cancelTool(event, toolUse, `ArmorIQ ${decision.action}: ${reason}`);
+            this.cancelTool(event, toolUse, `ArmorIQ ${decision.action}: ${reason}`, request);
         }
         catch (exc) {
+            await policySession?.otelSession?.endPolicy(policySpan ?? { span: null, name: 'armoriq.policy.evaluate' }, { error: exc });
             // Fail closed: never let a tool run if enforcement errored — and surface it.
             const msg = exc.message ?? String(exc);
             this.emit('error', { tool: toolName, error: msg });
-            this.cancelTool(event, toolUse, `ArmorIQ enforcement error (fail-closed): ${msg}`);
+            this.cancelTool(event, toolUse, `ArmorIQ enforcement error (fail-closed): ${msg}`, request);
         }
     }
     /**
@@ -317,31 +668,94 @@ class ArmorIQStrandsPlugin {
      * allowed to break the run.
      */
     async onAfterToolCall(event) {
+        if (this.isClosedInvocation(event))
+            return;
+        const request = this.requestFor(event);
+        const telemetryState = request ?? this;
         const toolUse = event?.toolUse ?? event?.tool_use ?? {};
         // Consume the mark so a later legitimate call to the same tool is reported.
         const key = ArmorIQStrandsPlugin.cancelKey(toolUse);
-        if (key && this.cancelledToolUseIds.delete(key))
-            return; // we cancelled it; it never ran
-        if (!this.session || !this.planStarted)
+        if (key && (request?.cancelledToolUseIds ?? this.cancelledToolUseIds).delete(key))
+            return;
+        const session = request?.session ?? this.session;
+        if (!session || !(request?.planStarted ?? this.planStarted))
             return;
         const toolName = toolUse.name ?? '';
         if (!toolName)
             return;
         const args = toolUse.input ?? {};
+        const itemOrdinal = telemetryState.toolOrdinals?.get(toolUse.toolUseId);
         const exc = event?.error;
+        if (exc) {
+            telemetryState.hadToolError = true;
+            telemetryState.pendingTerminalStatus = 'error';
+        }
         const status = exc ? 'error' : 'success';
         const errMsg = exc ? (exc.message ?? String(exc)) : undefined;
         const result = exc ? errMsg : event?.result;
         try {
-            await this.session.report(toolName, args, result, {
+            const toolSpan = telemetryState.toolSpans?.get(key);
+            telemetryState.toolSpans?.delete(key);
+            await session.otelSession?.endTool(toolSpan ?? { span: null, name: 'armoriq.tool' }, {
+                outcome: exc ? 'error' : 'success', error: exc,
+                result,
+            });
+            await session.report(toolName, args, result, {
                 status,
                 errorMessage: errMsg,
+                emitOtel: false,
+                operation: this.frameworkMcpOperation(toolName, itemOrdinal, toolUse.toolUseId),
             });
         }
         catch (reportExc) {
             console.warn(`[armoriq] strands execution report failed for ${toolName}: ${reportExc.message}`);
         }
     }
+    async onAfterInvocation(event) {
+        const invocationState = event?.invocationState;
+        const request = this.requestFor(event);
+        const telemetryState = request ?? this;
+        const status = request?.pendingTerminalStatus ?? this.terminalStatus(event, telemetryState);
+        const taskOutcome = this.taskOutcomeFor(event, request, status);
+        await this.closeRequest(request, status, taskOutcome);
+        if (invocationState && typeof invocationState === 'object') {
+            this.closedInvocationStates.add(invocationState);
+            this.invocationRequests.delete(invocationState);
+        }
+    }
+    /**
+     * Strands' AfterInvocationEvent carries no `.error` field in the 1.11.2
+     * contract — an ordinary invocation failure (the framework's agent loop
+     * throwing, most commonly a non-retried model error) is rethrown by the
+     * generator right after this terminal hook runs, invisible to the event
+     * itself. `onAfterModelCall` tracks that on `telemetryState.invocationFailed`
+     * as it observes each model turn, so this only has to consult it here.
+     * Native AbortSignal reasons (timeout/disconnect/cancelled) are a more
+     * specific, intentional stop and take priority over a generic error.
+     */
+    terminalStatus(event, telemetryState) {
+        const signal = event?.agent?.cancelSignal;
+        if (signal?.aborted) {
+            const reason = signal.reason;
+            const label = String(reason?.name ?? reason?.code ?? reason ?? '').toLowerCase();
+            if (label.includes('timeout'))
+                return 'timeout';
+            if (label.includes('disconnect') || label.includes('socket') || label.includes('client')) {
+                return 'disconnected';
+            }
+            return 'cancelled';
+        }
+        if (event?.error || telemetryState?.invocationFailed)
+            return 'error';
+        return 'ok';
+    }
+    taskOutcomeFor(event, request, status) {
+        const stopReason = event?.result?.stopReason ?? event?.result?.stop_reason;
+        const hadToolError = request?.hadToolError ?? this.hadToolError;
+        return status === 'error' && hadToolError && stopReason === 'end_turn'
+            ? 'partially_completed'
+            : undefined;
+    }
 }
 exports.ArmorIQStrandsPlugin = ArmorIQStrandsPlugin;
 //# sourceMappingURL=strands.js.map