maka-agent 0.2.0-dev.4.20260830 → 0.2.0-dev.41.20260918

package/node_modules/@openai/agents-core/dist/runner/guardrails.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createGuardrailTracker = void 0;
+exports.getSerializedOutputGuardrailResults = getSerializedOutputGuardrailResults;
 exports.buildInputGuardrailDefinitions = buildInputGuardrailDefinitions;
 exports.splitInputGuardrails = splitInputGuardrails;
 exports.runInputGuardrails = runInputGuardrails;
@@ -9,6 +10,7 @@ exports.finalizeOutputGuardrails = finalizeOutputGuardrails;
 exports.sanitizeBlockedOutputGuardrailError = sanitizeBlockedOutputGuardrailError;
 exports.sanitizeBlockedOutputGuardrailErrorDetails = sanitizeBlockedOutputGuardrailErrorDetails;
 exports.sanitizeBlockedOutputGuardrailResults = sanitizeBlockedOutputGuardrailResults;
+exports.replaceSanitizedOutputGuardrailMessages = replaceSanitizedOutputGuardrailMessages;
 exports.sanitizeBlockedToolOutputGuardrailResults = sanitizeBlockedToolOutputGuardrailResults;
 const errors_1 = require("../errors.js");
 const guardrail_1 = require("../guardrail.js");
@@ -77,20 +79,30 @@ const createGuardrailTracker = () => {
 };
 exports.createGuardrailTracker = createGuardrailTracker;
 const currentResponseOutputGuardrailResults = new WeakMap();
+/** Validates restored result ownership without publishing live ownership evidence. */
+function getSerializedOutputGuardrailResults(state, blockedOutput) {
+    const results = new Set();
+    for (const result of state._outputGuardrailResults) {
+        if (result.agent !== state._currentAgent) {
+            continue;
+        }
+        if (result.agentOutput !== blockedOutput ||
+            result.output.outputInfo !== undefined) {
+            throw new errors_1.UserError('Cannot resume this serialized terminal output because previous output guardrail result ownership was not preserved. Continue the live RunState or start a new run from safe input.');
+        }
+        results.add(result);
+    }
+    return results;
+}
 function getCurrentResponseOutputGuardrailResults(state, guardedTerminalToolOutput, redactedOutput) {
     const existing = currentResponseOutputGuardrailResults.get(state);
     if (existing && existing.response === state._lastTurnResponse) {
         return existing.results;
     }
-    const results = new Set();
-    if (guardedTerminalToolOutput &&
-        state._serializedCurrentStep === state._currentStep) {
-        if (state._outputGuardrailResults.some((result) => result.agent === state._currentAgent &&
-            (result.agentOutput !== redactedOutput ||
-                result.output.outputInfo !== undefined))) {
-            throw new errors_1.UserError('Cannot resume this serialized terminal output because previous output guardrail result ownership was not preserved. Continue the live RunState or start a new run from safe input.');
-        }
-    }
+    const results = guardedTerminalToolOutput &&
+        state._serializedCurrentStep === state._currentStep
+        ? getSerializedOutputGuardrailResults(state, redactedOutput)
+        : new Set();
     currentResponseOutputGuardrailResults.set(state, {
         response: state._lastTurnResponse,
         results,
@@ -223,7 +235,7 @@ async function runOutputGuardrails(state, runnerOutputGuardrails, output, onResu
     });
 }
 async function finalizeOutputGuardrails(options) {
-    const { state, runnerOutputGuardrails, output, redactedOutput, guardedTerminalToolOutput, signal, sanitizeRejectedOutput, persistBlockedOutput, persistUnblockedFailure, releaseBlockedOutputPersistence, } = options;
+    const { state, runnerOutputGuardrails, output, redactedOutput, guardedTerminalToolOutput, signal, sanitizeRejectedOutput, persistBlockedOutput, persistUnblockedFailure, onBlockedOutput, releaseBlockedOutputPersistence, } = options;
     if (runnerOutputGuardrails.length === 0 &&
         state._currentAgent.outputGuardrails.length === 0) {
         return;
@@ -242,13 +254,24 @@ async function finalizeOutputGuardrails(options) {
         });
     }
     catch (error) {
-        const outputBlocked = sanitizeRejectedOutput(state, outputGuardrailResultStart, completedTripwireResult, observedResults, error instanceof errors_1.OutputGuardrailTripwireTriggered ? error : undefined, ownedGuardrailResults);
+        const currentTripwireResult = state._outputGuardrailResults
+            .slice(outputGuardrailResultStart)
+            .find((result) => ownedGuardrailResults.has(result) &&
+            observedResults.get(result) === true) ?? completedTripwireResult;
+        const outputBlockedResult = sanitizeRejectedOutput(state, outputGuardrailResultStart, currentTripwireResult, observedResults, error instanceof errors_1.OutputGuardrailTripwireTriggered ? error : undefined, ownedGuardrailResults);
+        const outputBlockedMessage = typeof outputBlockedResult === 'string' || outputBlockedResult === false
+            ? outputBlockedResult
+            : await outputBlockedResult;
+        signal?.throwIfAborted();
+        const outputBlocked = outputBlockedMessage !== false;
+        const blockedMessage = outputBlockedMessage || redactedOutput;
         const guardrailError = outputBlocked
-            ? sanitizeBlockedOutputGuardrailError(error, output, redactedOutput, state)
+            ? sanitizeBlockedOutputGuardrailError(error, output, blockedMessage, state, currentTripwireResult)
             : error;
         const completedOutputTripwireError = completedTripwireResult !== undefined &&
             guardrailError instanceof errors_1.OutputGuardrailTripwireTriggered;
         if (outputBlocked || completedOutputTripwireError) {
+            onBlockedOutput?.();
             if (persistBlockedOutput && !signal?.aborted) {
                 try {
                     await persistBlockedOutput();
@@ -261,7 +284,7 @@ async function finalizeOutputGuardrails(options) {
                         !(0, finalOutputError_1.isDataRedactedError)(guardrailError)) {
                         guardrailError.cause =
                             outputBlocked
-                                ? sanitizeBlockedOutputGuardrailErrorDetails(persistenceError, output, redactedOutput, state)
+                                ? sanitizeBlockedOutputGuardrailErrorDetails(persistenceError, output, blockedMessage, state)
                                 : persistenceError;
                     }
                 }
@@ -282,9 +305,9 @@ async function finalizeOutputGuardrails(options) {
         throw guardrailError;
     }
 }
-function sanitizeBlockedOutputGuardrailError(error, rejectedOutput, redactedOutput, state) {
+function sanitizeBlockedOutputGuardrailError(error, rejectedOutput, redactedOutput, state, currentTripwireResult) {
     if (error instanceof errors_1.OutputGuardrailTripwireTriggered) {
-        const completedResult = state._outputGuardrailResults.find((result) => result.agent === state._currentAgent && result.output.tripwireTriggered) ?? {
+        const completedResult = {
             guardrail: { type: 'output', name: 'output_guardrail' },
             agent: state._currentAgent,
             agentOutput: redactedOutput,
@@ -293,6 +316,15 @@ function sanitizeBlockedOutputGuardrailError(error, rejectedOutput, redactedOutp
                 outputInfo: undefined,
             },
         };
+        try {
+            const guardrailName = currentTripwireResult?.guardrail.name;
+            if (typeof guardrailName === 'string' && guardrailName.length > 0) {
+                completedResult.guardrail.name = guardrailName;
+            }
+        }
+        catch {
+            // Keep the safe fallback name when caller-owned metadata is unreadable.
+        }
         return new errors_1.OutputGuardrailTripwireTriggered('Output guardrail triggered.', completedResult, state);
     }
     if (!(error instanceof errors_1.GuardrailExecutionError)) {
@@ -332,6 +364,7 @@ function sanitizeBlockedOutputGuardrailResults(state, resultStartIndex, redacted
     const results = state._outputGuardrailResults;
     const sanitizedResults = [];
     const replacements = new Map();
+    const sanitizedOwnedResults = new Set();
     for (let index = 0; index < resultStartIndex; index += 1) {
         try {
             const result = results[index];
@@ -342,6 +375,7 @@ function sanitizeBlockedOutputGuardrailResults(state, resultStartIndex, redacted
             const replacement = cloneSanitizedOutputGuardrailResult(result, redactedOutput, false);
             if (replacement) {
                 replacements.set(result, replacement);
+                sanitizedOwnedResults.add(replacement);
                 sanitizedResults.push(replacement);
             }
         }
@@ -364,6 +398,7 @@ function sanitizeBlockedOutputGuardrailResults(state, resultStartIndex, redacted
                 }
                 replacements.set(result, replacement);
             }
+            sanitizedOwnedResults.add(replacement);
             sanitizedResults.push(replacement);
         }
         catch {
@@ -385,9 +420,39 @@ function sanitizeBlockedOutputGuardrailResults(state, resultStartIndex, redacted
                 outputInfo: undefined,
             },
         };
+        sanitizedOwnedResults.add(tripwire.result);
         tripwire.message = 'Output guardrail triggered.';
         tripwire.stack = `${tripwire.name}: ${tripwire.message}`;
     }
+    currentResponseOutputGuardrailResults.set(state, {
+        response: state._lastTurnResponse,
+        results: sanitizedOwnedResults,
+    });
+    return sanitizedOwnedResults;
+}
+function replaceSanitizedOutputGuardrailMessages(state, sanitizedOwnedResults, redactedOutput, tripwire) {
+    const replacements = new Map();
+    state._outputGuardrailResults = state._outputGuardrailResults.map((result) => {
+        if (!sanitizedOwnedResults.has(result)) {
+            return result;
+        }
+        const replacement = cloneSanitizedOutputGuardrailResult(result, redactedOutput, result.output.tripwireTriggered);
+        if (!replacement) {
+            return result;
+        }
+        replacements.set(result, replacement);
+        return replacement;
+    });
+    if (tripwire && sanitizedOwnedResults.has(tripwire.result)) {
+        tripwire.result =
+            replacements.get(tripwire.result) ??
+                cloneSanitizedOutputGuardrailResult(tripwire.result, redactedOutput, true) ??
+                tripwire.result;
+    }
+    currentResponseOutputGuardrailResults.set(state, {
+        response: state._lastTurnResponse,
+        results: new Set(replacements.values()),
+    });
 }
 function sanitizeBlockedToolOutputGuardrailResults(state, resultStartIndex, redactedOutput) {
     const results = state._toolOutputGuardrailResults;

package/node_modules/@openai/agents-core/dist/runner/guardrails.mjs

@@ -64,20 +64,30 @@ export const createGuardrailTracker = () => {
     };
 };
 const currentResponseOutputGuardrailResults = new WeakMap();
+/** Validates restored result ownership without publishing live ownership evidence. */
+export function getSerializedOutputGuardrailResults(state, blockedOutput) {
+    const results = new Set();
+    for (const result of state._outputGuardrailResults) {
+        if (result.agent !== state._currentAgent) {
+            continue;
+        }
+        if (result.agentOutput !== blockedOutput ||
+            result.output.outputInfo !== undefined) {
+            throw new UserError('Cannot resume this serialized terminal output because previous output guardrail result ownership was not preserved. Continue the live RunState or start a new run from safe input.');
+        }
+        results.add(result);
+    }
+    return results;
+}
 function getCurrentResponseOutputGuardrailResults(state, guardedTerminalToolOutput, redactedOutput) {
     const existing = currentResponseOutputGuardrailResults.get(state);
     if (existing && existing.response === state._lastTurnResponse) {
         return existing.results;
     }
-    const results = new Set();
-    if (guardedTerminalToolOutput &&
-        state._serializedCurrentStep === state._currentStep) {
-        if (state._outputGuardrailResults.some((result) => result.agent === state._currentAgent &&
-            (result.agentOutput !== redactedOutput ||
-                result.output.outputInfo !== undefined))) {
-            throw new UserError('Cannot resume this serialized terminal output because previous output guardrail result ownership was not preserved. Continue the live RunState or start a new run from safe input.');
-        }
-    }
+    const results = guardedTerminalToolOutput &&
+        state._serializedCurrentStep === state._currentStep
+        ? getSerializedOutputGuardrailResults(state, redactedOutput)
+        : new Set();
     currentResponseOutputGuardrailResults.set(state, {
         response: state._lastTurnResponse,
         results,
@@ -210,7 +220,7 @@ export async function runOutputGuardrails(state, runnerOutputGuardrails, output,
     });
 }
 export async function finalizeOutputGuardrails(options) {
-    const { state, runnerOutputGuardrails, output, redactedOutput, guardedTerminalToolOutput, signal, sanitizeRejectedOutput, persistBlockedOutput, persistUnblockedFailure, releaseBlockedOutputPersistence, } = options;
+    const { state, runnerOutputGuardrails, output, redactedOutput, guardedTerminalToolOutput, signal, sanitizeRejectedOutput, persistBlockedOutput, persistUnblockedFailure, onBlockedOutput, releaseBlockedOutputPersistence, } = options;
     if (runnerOutputGuardrails.length === 0 &&
         state._currentAgent.outputGuardrails.length === 0) {
         return;
@@ -229,13 +239,24 @@ export async function finalizeOutputGuardrails(options) {
         });
     }
     catch (error) {
-        const outputBlocked = sanitizeRejectedOutput(state, outputGuardrailResultStart, completedTripwireResult, observedResults, error instanceof OutputGuardrailTripwireTriggered ? error : undefined, ownedGuardrailResults);
+        const currentTripwireResult = state._outputGuardrailResults
+            .slice(outputGuardrailResultStart)
+            .find((result) => ownedGuardrailResults.has(result) &&
+            observedResults.get(result) === true) ?? completedTripwireResult;
+        const outputBlockedResult = sanitizeRejectedOutput(state, outputGuardrailResultStart, currentTripwireResult, observedResults, error instanceof OutputGuardrailTripwireTriggered ? error : undefined, ownedGuardrailResults);
+        const outputBlockedMessage = typeof outputBlockedResult === 'string' || outputBlockedResult === false
+            ? outputBlockedResult
+            : await outputBlockedResult;
+        signal?.throwIfAborted();
+        const outputBlocked = outputBlockedMessage !== false;
+        const blockedMessage = outputBlockedMessage || redactedOutput;
         const guardrailError = outputBlocked
-            ? sanitizeBlockedOutputGuardrailError(error, output, redactedOutput, state)
+            ? sanitizeBlockedOutputGuardrailError(error, output, blockedMessage, state, currentTripwireResult)
             : error;
         const completedOutputTripwireError = completedTripwireResult !== undefined &&
             guardrailError instanceof OutputGuardrailTripwireTriggered;
         if (outputBlocked || completedOutputTripwireError) {
+            onBlockedOutput?.();
             if (persistBlockedOutput && !signal?.aborted) {
                 try {
                     await persistBlockedOutput();
@@ -248,7 +269,7 @@ export async function finalizeOutputGuardrails(options) {
                         !isDataRedactedError(guardrailError)) {
                         guardrailError.cause =
                             outputBlocked
-                                ? sanitizeBlockedOutputGuardrailErrorDetails(persistenceError, output, redactedOutput, state)
+                                ? sanitizeBlockedOutputGuardrailErrorDetails(persistenceError, output, blockedMessage, state)
                                 : persistenceError;
                     }
                 }
@@ -269,9 +290,9 @@ export async function finalizeOutputGuardrails(options) {
         throw guardrailError;
     }
 }
-export function sanitizeBlockedOutputGuardrailError(error, rejectedOutput, redactedOutput, state) {
+export function sanitizeBlockedOutputGuardrailError(error, rejectedOutput, redactedOutput, state, currentTripwireResult) {
     if (error instanceof OutputGuardrailTripwireTriggered) {
-        const completedResult = state._outputGuardrailResults.find((result) => result.agent === state._currentAgent && result.output.tripwireTriggered) ?? {
+        const completedResult = {
             guardrail: { type: 'output', name: 'output_guardrail' },
             agent: state._currentAgent,
             agentOutput: redactedOutput,
@@ -280,6 +301,15 @@ export function sanitizeBlockedOutputGuardrailError(error, rejectedOutput, redac
                 outputInfo: undefined,
             },
         };
+        try {
+            const guardrailName = currentTripwireResult?.guardrail.name;
+            if (typeof guardrailName === 'string' && guardrailName.length > 0) {
+                completedResult.guardrail.name = guardrailName;
+            }
+        }
+        catch {
+            // Keep the safe fallback name when caller-owned metadata is unreadable.
+        }
         return new OutputGuardrailTripwireTriggered('Output guardrail triggered.', completedResult, state);
     }
     if (!(error instanceof GuardrailExecutionError)) {
@@ -319,6 +349,7 @@ export function sanitizeBlockedOutputGuardrailResults(state, resultStartIndex, r
     const results = state._outputGuardrailResults;
     const sanitizedResults = [];
     const replacements = new Map();
+    const sanitizedOwnedResults = new Set();
     for (let index = 0; index < resultStartIndex; index += 1) {
         try {
             const result = results[index];
@@ -329,6 +360,7 @@ export function sanitizeBlockedOutputGuardrailResults(state, resultStartIndex, r
             const replacement = cloneSanitizedOutputGuardrailResult(result, redactedOutput, false);
             if (replacement) {
                 replacements.set(result, replacement);
+                sanitizedOwnedResults.add(replacement);
                 sanitizedResults.push(replacement);
             }
         }
@@ -351,6 +383,7 @@ export function sanitizeBlockedOutputGuardrailResults(state, resultStartIndex, r
                 }
                 replacements.set(result, replacement);
             }
+            sanitizedOwnedResults.add(replacement);
             sanitizedResults.push(replacement);
         }
         catch {
@@ -372,9 +405,39 @@ export function sanitizeBlockedOutputGuardrailResults(state, resultStartIndex, r
                 outputInfo: undefined,
             },
         };
+        sanitizedOwnedResults.add(tripwire.result);
         tripwire.message = 'Output guardrail triggered.';
         tripwire.stack = `${tripwire.name}: ${tripwire.message}`;
     }
+    currentResponseOutputGuardrailResults.set(state, {
+        response: state._lastTurnResponse,
+        results: sanitizedOwnedResults,
+    });
+    return sanitizedOwnedResults;
+}
+export function replaceSanitizedOutputGuardrailMessages(state, sanitizedOwnedResults, redactedOutput, tripwire) {
+    const replacements = new Map();
+    state._outputGuardrailResults = state._outputGuardrailResults.map((result) => {
+        if (!sanitizedOwnedResults.has(result)) {
+            return result;
+        }
+        const replacement = cloneSanitizedOutputGuardrailResult(result, redactedOutput, result.output.tripwireTriggered);
+        if (!replacement) {
+            return result;
+        }
+        replacements.set(result, replacement);
+        return replacement;
+    });
+    if (tripwire && sanitizedOwnedResults.has(tripwire.result)) {
+        tripwire.result =
+            replacements.get(tripwire.result) ??
+                cloneSanitizedOutputGuardrailResult(tripwire.result, redactedOutput, true) ??
+                tripwire.result;
+    }
+    currentResponseOutputGuardrailResults.set(state, {
+        response: state._lastTurnResponse,
+        results: new Set(replacements.values()),
+    });
 }
 export function sanitizeBlockedToolOutputGuardrailResults(state, resultStartIndex, redactedOutput) {
     const results = state._toolOutputGuardrailResults;

package/node_modules/@openai/agents-core/dist/runner/items.js

@@ -244,7 +244,8 @@ function extractOutputItemsFromRunItems(items, reasoningItemIdPolicy) {
         if (cached) {
             return cached;
         }
-        const withoutNullStatusItem = withoutNullStatus(item.rawItem);
+        const withoutOutputOnlyMetadata = stripOutputOnlyCreatedBy(item.rawItem);
+        const withoutNullStatusItem = withoutNullStatus(withoutOutputOnlyMetadata);
         const normalizedItem = normalizationKey === 'omit'
             ? stripReasoningItemIdForPolicy(withoutNullStatusItem, reasoningItemIdPolicy)
             : withoutNullStatusItem;
@@ -254,6 +255,36 @@ function extractOutputItemsFromRunItems(items, reasoningItemIdPolicy) {
         return normalizedItem;
     });
 }
+function stripOutputOnlyCreatedBy(item) {
+    if (!item || typeof item !== 'object') {
+        return item;
+    }
+    const candidate = item;
+    const hasTopLevelCreatedBy = Object.prototype.hasOwnProperty.call(candidate, 'created_by');
+    const output = candidate.output;
+    const hasShellOutputCreatedBy = candidate.type === 'shell_call_output' &&
+        Array.isArray(output) &&
+        output.some((entry) => entry !== null &&
+            typeof entry === 'object' &&
+            Object.prototype.hasOwnProperty.call(entry, 'created_by'));
+    if (!hasTopLevelCreatedBy && !hasShellOutputCreatedBy) {
+        return item;
+    }
+    const { created_by: _createdBy, ...withoutCreatedBy } = candidate;
+    const normalized = withoutCreatedBy;
+    if (hasShellOutputCreatedBy) {
+        normalized.output = output.map((entry) => {
+            if (entry === null ||
+                typeof entry !== 'object' ||
+                !Object.prototype.hasOwnProperty.call(entry, 'created_by')) {
+                return entry;
+            }
+            const { created_by: _chunkCreatedBy, ...withoutChunkCreatedBy } = entry;
+            return withoutChunkCreatedBy;
+        });
+    }
+    return normalized;
+}
 function withoutNullStatus(item) {
     if (!item ||
         typeof item !== 'object' ||
@@ -505,7 +536,9 @@ function getTurnInput(originalInput, generatedItems, reasoningItemIdPolicy) {
 }
 function trimToLatestCompaction(items) {
     for (let index = items.length - 1; index >= 0; index -= 1) {
-        if (items[index]?.type === 'compaction') {
+        const item = items[index];
+        const rawItem = item && 'rawItem' in item ? item.rawItem : item;
+        if (rawItem?.type === 'compaction') {
             return items.slice(index);
         }
     }

package/node_modules/@openai/agents-core/dist/runner/items.mjs

@@ -191,7 +191,8 @@ export function extractOutputItemsFromRunItems(items, reasoningItemIdPolicy) {
         if (cached) {
             return cached;
         }
-        const withoutNullStatusItem = withoutNullStatus(item.rawItem);
+        const withoutOutputOnlyMetadata = stripOutputOnlyCreatedBy(item.rawItem);
+        const withoutNullStatusItem = withoutNullStatus(withoutOutputOnlyMetadata);
         const normalizedItem = normalizationKey === 'omit'
             ? stripReasoningItemIdForPolicy(withoutNullStatusItem, reasoningItemIdPolicy)
             : withoutNullStatusItem;
@@ -201,6 +202,36 @@ export function extractOutputItemsFromRunItems(items, reasoningItemIdPolicy) {
         return normalizedItem;
     });
 }
+function stripOutputOnlyCreatedBy(item) {
+    if (!item || typeof item !== 'object') {
+        return item;
+    }
+    const candidate = item;
+    const hasTopLevelCreatedBy = Object.prototype.hasOwnProperty.call(candidate, 'created_by');
+    const output = candidate.output;
+    const hasShellOutputCreatedBy = candidate.type === 'shell_call_output' &&
+        Array.isArray(output) &&
+        output.some((entry) => entry !== null &&
+            typeof entry === 'object' &&
+            Object.prototype.hasOwnProperty.call(entry, 'created_by'));
+    if (!hasTopLevelCreatedBy && !hasShellOutputCreatedBy) {
+        return item;
+    }
+    const { created_by: _createdBy, ...withoutCreatedBy } = candidate;
+    const normalized = withoutCreatedBy;
+    if (hasShellOutputCreatedBy) {
+        normalized.output = output.map((entry) => {
+            if (entry === null ||
+                typeof entry !== 'object' ||
+                !Object.prototype.hasOwnProperty.call(entry, 'created_by')) {
+                return entry;
+            }
+            const { created_by: _chunkCreatedBy, ...withoutChunkCreatedBy } = entry;
+            return withoutChunkCreatedBy;
+        });
+    }
+    return normalized;
+}
 function withoutNullStatus(item) {
     if (!item ||
         typeof item !== 'object' ||
@@ -452,7 +483,9 @@ export function getTurnInput(originalInput, generatedItems, reasoningItemIdPolic
 }
 export function trimToLatestCompaction(items) {
     for (let index = items.length - 1; index >= 0; index -= 1) {
-        if (items[index]?.type === 'compaction') {
+        const item = items[index];
+        const rawItem = item && 'rawItem' in item ? item.rawItem : item;
+        if (rawItem?.type === 'compaction') {
             return items.slice(index);
         }
     }

package/node_modules/@openai/agents-core/dist/runner/modelOutputs.js

@@ -12,6 +12,7 @@ const types_1 = require("./types.js");
 const toolSearch_1 = require("./toolSearch.js");
 const toolCaller_1 = require("./toolCaller.js");
 const items_2 = require("./items.js");
+const toolSearchAttribution_1 = require("./toolSearchAttribution.js");
 function ensureToolAvailable(tool, message, data) {
     if (!tool) {
         (0, context_1.addErrorToCurrentSpan)({
@@ -134,12 +135,13 @@ function throwFunctionToolNotFound(toolName, agent) {
     });
     throw new errors_1.ModelBehaviorError(message);
 }
-function recordMissingFunctionTool(output, toolName, agent, items, toolsUsed, functionToolsNotFound) {
+function recordMissingFunctionTool(output, toolName, agent, items, toolsUsed, functionToolsNotFound, reason) {
     toolsUsed.push(toolName);
     items.push(new items_1.RunToolCallItem(output, agent));
     functionToolsNotFound.push({
         toolCall: output,
         toolName,
+        ...(reason ? { reason } : {}),
     });
 }
 function normalizeFunctionToolCallForStorage(toolCall, tool) {
@@ -187,21 +189,29 @@ function recordLoadedToolSearchOutput(state, toolSearchOutput) {
     }
     refreshLoadedDeferredToolNames(state);
 }
-function collectLoadedDeferredToolStateFromHistory(items, agent) {
+function collectLoadedDeferredToolStateFromHistory(items, agent, agentName) {
     const state = {
         anonymousToolSearchOutputs: [],
         keyedToolSearchOutputsByKey: new Map(),
         loadedToolNames: new Set(),
     };
-    for (const item of items) {
-        if (item instanceof items_1.RunToolSearchOutputItem &&
-            item.agent.name !== agent.name) {
+    // Use the active history boundary without discarding the surviving item owners.
+    for (const item of (0, items_2.trimToLatestCompaction)(items)) {
+        if ((item instanceof items_1.RunToolSearchOutputItem ||
+            item instanceof items_1.RunInputItem) &&
+            item.agent !== agent) {
             continue;
         }
         const rawItem = getRawAgentInputItem(item);
         if (rawItem?.type !== 'tool_search_output') {
             continue;
         }
+        // Raw history has no live owner; only an unambiguous recorded name can restore discovery.
+        if (!(item instanceof items_1.RunToolSearchOutputItem) &&
+            (typeof agentName !== 'string' ||
+                rawItem.toolSearchAgentName !== agentName)) {
+            continue;
+        }
         const replacementKey = (0, utils_1.getToolSearchOutputReplacementKey)(rawItem);
         if (replacementKey) {
             state.keyedToolSearchOutputsByKey.set(replacementKey, rawItem);
@@ -318,9 +328,9 @@ async function buildGeneratedClientToolSearchOutputMapAsync(args) {
     }
     return generatedOutputs;
 }
-function ensureDeferredFunctionToolLoaded(toolCall, tool, loadedToolNames, agent) {
+function checkDeferredFunctionToolLoaded(toolCall, tool, loadedToolNames, agent, behavior) {
     if (tool.deferLoading !== true) {
-        return;
+        return true;
     }
     const explicitNamespace = (0, toolIdentity_1.getFunctionToolNamespace)(tool);
     const qualifiedName = (0, toolIdentity_1.getFunctionToolQualifiedName)(tool);
@@ -328,7 +338,10 @@ function ensureDeferredFunctionToolLoaded(toolCall, tool, loadedToolNames, agent
         ((!explicitNamespace || explicitNamespace === tool.name) &&
             loadedToolNames.has(tool.name));
     if (isLoaded) {
-        return;
+        return true;
+    }
+    if (behavior === 'return_error_to_model') {
+        return false;
     }
     const toolName = qualifiedName ?? tool.name;
     const message = `Model produced deferred function call ${toolName} before it was loaded via tool_search.`;
@@ -393,7 +406,7 @@ function processModelResponse(modelResponse, agent, tools, handoffs, priorItems
     const hasClientToolSearchTool = tools.some((tool) => tool.type === 'hosted_tool' &&
         tool.providerData?.type === 'tool_search' &&
         tool.providerData.execution === 'client');
-    const loadedDeferredToolState = collectLoadedDeferredToolStateFromHistory(priorItems, agent);
+    const loadedDeferredToolState = collectLoadedDeferredToolStateFromHistory(priorItems, agent, processingOptions.toolSearchAgentName);
     seedHostedMcpToolsFromLoadedDeferredToolState(loadedDeferredToolState, mcpToolMap, originalMcpServerLabels);
     const generatedClientToolSearchOutputsByCall = buildGeneratedClientToolSearchOutputMap(modelResponse, tools, hasClientToolSearchTool);
     let hasGeneratedClientToolSearchOutputs = false;
@@ -408,7 +421,7 @@ function processModelResponse(modelResponse, agent, tools, handoffs, priorItems
             toolsUsed.push('tool_search');
             const generatedOutput = generatedClientToolSearchOutputsByCall.get(output);
             if (generatedOutput) {
-                items.push(new items_1.RunToolSearchOutputItem(generatedOutput, agent));
+                items.push(new items_1.RunToolSearchOutputItem((0, toolSearchAttribution_1.attributeToolSearchOutput)(generatedOutput, processingOptions.toolSearchAgentName), agent));
                 recordLoadedToolSearchOutput(loadedDeferredToolState, generatedOutput);
                 (0, toolSearch_1.addHostedMcpToolsFromToolSearchOutput)(generatedOutput, mcpToolMap, {
                     preserveExistingServerLabels: originalMcpServerLabels,
@@ -417,7 +430,7 @@ function processModelResponse(modelResponse, agent, tools, handoffs, priorItems
             }
         }
         else if (output.type === 'tool_search_output') {
-            items.push(new items_1.RunToolSearchOutputItem(output, agent));
+            items.push(new items_1.RunToolSearchOutputItem((0, toolSearchAttribution_1.attributeToolSearchOutput)(output, processingOptions.toolSearchAgentName), agent));
             recordLoadedToolSearchOutput(loadedDeferredToolState, output);
             (0, toolSearch_1.addHostedMcpToolsFromToolSearchOutput)(output, mcpToolMap, {
                 preserveExistingServerLabels: originalMcpServerLabels,
@@ -562,10 +575,16 @@ function processModelResponse(modelResponse, agent, tools, handoffs, priorItems
         }
         else {
             (0, toolCaller_1.ensureToolCallerAllowed)(output, resolved.tool.allowedCallers, (0, toolIdentity_1.getFunctionToolQualifiedName)(resolved.tool) ?? resolved.tool.name, agent);
-            ensureDeferredFunctionToolLoaded(output, resolved.tool, loadedDeferredToolState.loadedToolNames, agent);
+            if (!checkDeferredFunctionToolLoaded(output, resolved.tool, loadedDeferredToolState.loadedToolNames, agent, toolNotFoundBehavior)) {
+                recordMissingFunctionTool(normalizeFunctionToolCallForStorage(output, resolved.tool), (0, toolIdentity_1.getFunctionToolQualifiedName)(resolved.tool) ?? resolved.tool.name, agent, items, toolsUsed, functionToolsNotFound, 'not_loaded');
+                continue;
+            }
             const normalizedToolCall = normalizeFunctionToolCallForStorage(output, resolved.tool);
             toolsUsed.push((0, toolIdentity_1.getFunctionToolQualifiedName)(resolved.tool) ?? resolved.tool.name);
-            items.push(new items_1.RunToolCallItem(normalizedToolCall, agent));
+            items.push(new items_1.RunToolCallItem(normalizedToolCall, agent, !(0, toolIdentity_1.getToolCallNamespace)(normalizedToolCall) &&
+                (0, toolIdentity_1.isDeferredTopLevelFunctionTool)(resolved.tool)
+                ? (0, toolIdentity_1.getFunctionToolStateKey)(resolved.tool)
+                : undefined));
             runFunctions.push((0, types_1.createToolRunFunction)({
                 toolCall: normalizedToolCall,
                 tool: resolved.tool,
@@ -598,6 +617,10 @@ function processModelResponse(modelResponse, agent, tools, handoffs, priorItems
 }
 async function processModelResponseAsync(modelResponse, agent, tools, handoffs, state, priorItems = [], toolNotFoundBehavior = 'raise_error', processingOptions = {}) {
     (0, items_2.assertValidCompactionItems)(modelResponse.output);
+    processingOptions = {
+        ...processingOptions,
+        toolSearchAgentName: state._getToolSearchAgentName(agent),
+    };
     const clientToolSearchTool = (0, toolSearch_1.getClientToolSearchHelper)(tools);
     const hasCustomClientToolSearchExecutor = Boolean(clientToolSearchTool && (0, tool_1.getClientToolSearchExecutor)(clientToolSearchTool));
     const hasRelevantClientToolSearchCall = modelResponse.output.some((output) => output.type === 'tool_search_call' &&
@@ -632,7 +655,7 @@ async function processModelResponseAsync(modelResponse, agent, tools, handoffs,
         .getToolSearchRuntimeTools(agent)
         .map((tool) => (0, tool_1.getToolSearchRuntimeRoutingKey)(tool))
         .filter((key) => typeof key === 'string'));
-    const loadedDeferredToolState = collectLoadedDeferredToolStateFromHistory(priorItems, agent);
+    const loadedDeferredToolState = collectLoadedDeferredToolStateFromHistory(priorItems, agent, processingOptions.toolSearchAgentName);
     seedHostedMcpToolsFromLoadedDeferredToolState(loadedDeferredToolState, mcpToolMap, originalMcpServerLabels);
     const generatedClientToolSearchOutputsByCall = await buildGeneratedClientToolSearchOutputMapAsync({
         agent,
@@ -655,7 +678,7 @@ async function processModelResponseAsync(modelResponse, agent, tools, handoffs,
             toolsUsed.push('tool_search');
             const generatedOutput = generatedClientToolSearchOutputsByCall.get(output);
             if (generatedOutput) {
-                items.push(new items_1.RunToolSearchOutputItem(generatedOutput.output, agent));
+                items.push(new items_1.RunToolSearchOutputItem((0, toolSearchAttribution_1.attributeToolSearchOutput)(generatedOutput.output, processingOptions.toolSearchAgentName), agent));
                 recordLoadedToolSearchOutput(loadedDeferredToolState, generatedOutput.output);
                 (0, toolSearch_1.addHostedMcpToolsFromToolSearchOutput)(generatedOutput.output, mcpToolMap, {
                     preserveExistingServerLabels: originalMcpServerLabels,
@@ -675,7 +698,7 @@ async function processModelResponseAsync(modelResponse, agent, tools, handoffs,
             }
         }
         else if (output.type === 'tool_search_output') {
-            items.push(new items_1.RunToolSearchOutputItem(output, agent));
+            items.push(new items_1.RunToolSearchOutputItem((0, toolSearchAttribution_1.attributeToolSearchOutput)(output, processingOptions.toolSearchAgentName), agent));
             recordLoadedToolSearchOutput(loadedDeferredToolState, output);
             (0, toolSearch_1.addHostedMcpToolsFromToolSearchOutput)(output, mcpToolMap, {
                 preserveExistingServerLabels: originalMcpServerLabels,
@@ -809,10 +832,16 @@ async function processModelResponseAsync(modelResponse, agent, tools, handoffs,
         }
         else {
             (0, toolCaller_1.ensureToolCallerAllowed)(output, resolved.tool.allowedCallers, (0, toolIdentity_1.getFunctionToolQualifiedName)(resolved.tool) ?? resolved.tool.name, agent);
-            ensureDeferredFunctionToolLoaded(output, resolved.tool, loadedDeferredToolState.loadedToolNames, agent);
+            if (!checkDeferredFunctionToolLoaded(output, resolved.tool, loadedDeferredToolState.loadedToolNames, agent, toolNotFoundBehavior)) {
+                recordMissingFunctionTool(normalizeFunctionToolCallForStorage(output, resolved.tool), (0, toolIdentity_1.getFunctionToolQualifiedName)(resolved.tool) ?? resolved.tool.name, agent, items, toolsUsed, functionToolsNotFound, 'not_loaded');
+                continue;
+            }
             const normalizedToolCall = normalizeFunctionToolCallForStorage(output, resolved.tool);
             toolsUsed.push((0, toolIdentity_1.getFunctionToolQualifiedName)(resolved.tool) ?? resolved.tool.name);
-            items.push(new items_1.RunToolCallItem(normalizedToolCall, agent));
+            items.push(new items_1.RunToolCallItem(normalizedToolCall, agent, !(0, toolIdentity_1.getToolCallNamespace)(normalizedToolCall) &&
+                (0, toolIdentity_1.isDeferredTopLevelFunctionTool)(resolved.tool)
+                ? (0, toolIdentity_1.getFunctionToolStateKey)(resolved.tool)
+                : undefined));
             runFunctions.push((0, types_1.createToolRunFunction)({
                 toolCall: normalizedToolCall,
                 tool: resolved.tool,