experimental-ash 0.22.0 → 0.22.2

package/dist/src/harness/tool-loop.js

@@ -9,6 +9,7 @@ import { createCompactionCompletedEvent, createCompactionRequestedEvent, createI
 import { ASK_QUESTION_TOOL_NAME } from "#runtime/framework-tools/ask-question.js";
 import { ConnectionRegistryKey, DiscoveredConnectionToolsKey, } from "#runtime/framework-tools/connection-search.js";
 import { resolveConnectionToolsFromState } from "#runtime/framework-tools/connection-tools.js";
+import { WEB_SEARCH_TOOL_DEFINITION } from "#runtime/framework-tools/web-search.js";
 import { hydrateSandboxAttachments, stageAttachmentsToSandbox, } from "#harness/attachment-staging.js";
 import { compactMessages, getInputTokenCount, resolveCompactionModel, shouldCompact, } from "#harness/compaction.js";
 import { advanceStep, emitFailedStep, emitRecoverableFailedTurn, emitStreamContent, emitTurnEpilogue, emitTurnPreamble, getHarnessEmissionState, setHarnessEmissionState, } from "#harness/emission.js";
@@ -16,9 +17,10 @@ import { extractQuestionInputRequests, extractToolApprovalInputRequests, } from
 import { consumeDeferredStepInput, getApprovedTools, hasDeferredStepInput, hasStepInput, resolvePendingInput, setPendingInputBatch, } from "#harness/input-requests.js";
 import { getInstrumentationConfig } from "#harness/instrumentation-config.js";
 import { resolveAssistantStepText } from "#harness/messages.js";
-import { classifyModelCallError, extractModelCallErrorDetails, summarizeKnownModelCallConfigError, summarizeKnownModelCallRequestError, } from "#harness/model-call-error.js";
+import { classifyModelCallError, extractModelCallErrorDetails, extractUnsupportedProviderToolTypes, summarizeKnownModelCallConfigError, summarizeKnownModelCallRequestError, } from "#harness/model-call-error.js";
 import { ensureOtelIntegration } from "#harness/otel-integration.js";
 import { applyLastToolCacheBreakpoint, detectPromptCachePath, getAnthropicCacheMarker, } from "#harness/prompt-cache.js";
+import { resolveFrameworkToolFromUpstreamType, resolveGatewayPinForWebSearchBackend, resolveWebSearchBackend, } from "#harness/provider-tools.js";
 import { createRuntimeActionRequestFromToolCall, resolvePendingRuntimeActions, setPendingRuntimeActionBatch, } from "#harness/runtime-actions.js";
 import { buildStepHooks, emitStepActions, isInvalidToolCall, } from "#harness/step-hooks.js";
 import { pruneToolResults } from "#harness/tool-result-pruning.js";
@@ -81,6 +83,36 @@ function buildTelemetryRuntimeContext(authored, session) {
         "ash.version": ashVersion,
     };
 }
+/**
+ * Resolves the gateway provider slug to pin via
+ * `providerOptions.gateway.only` for one harness step, or `undefined`
+ * when no pin is needed.
+ *
+ * A pin is added when all of:
+ * 1. The model is gateway-routed (the `gateway-auto` cache path —
+ *    matches the existing `gateway.caching` hint condition).
+ * 2. The effective toolset includes a framework provider tool whose
+ *    backend pins to one provider (e.g. `web_search` on Anthropic).
+ *
+ * The author keeps the final say via `providerOptions.gateway.only` or
+ * `.order` on their model reference — those overrides flow through
+ * {@link mergeGatewayProviderPin} which is a no-op when either field is
+ * already set.
+ */
+function resolveGatewayPinForStep(input) {
+    if (input.cachePath.kind !== "gateway-auto") {
+        return undefined;
+    }
+    if (input.tools[WEB_SEARCH_TOOL_DEFINITION.name] === undefined) {
+        return undefined;
+    }
+    const backend = resolveWebSearchBackend(input.modelReference);
+    if (backend === null) {
+        return undefined;
+    }
+    const pin = resolveGatewayPinForWebSearchBackend(backend);
+    return pin ?? undefined;
+}
 /**
  * Builds AI Gateway app attribution headers when the model is gateway-routed.
  *
@@ -260,33 +292,11 @@ export function createToolLoopHarness(config) {
             telemetry: enrichTelemetry(telemetryConfig, agentName) ?? undefined,
         }));
         const approvedTools = getApprovedTools(session);
-        const tools = await buildToolSetWithProviderTools({
-            approvedTools,
-            capabilities: config.capabilities,
-            modelReference: session.agent.modelReference,
-            tools: config.tools,
-        });
         // Inject connection tools discovered by a prior `connection_search`.
         // Direct harness unit tests may run without an ambient context.
         const ctx = contextStorage.getStore();
         const registry = ctx?.get(ConnectionRegistryKey);
         const discovered = ctx?.get(DiscoveredConnectionToolsKey);
-        if (registry !== undefined && discovered !== undefined) {
-            const connectionTools = await resolveConnectionToolsFromState(registry, discovered, {
-                approvedTools,
-                existingToolNames: new Set(Object.keys(tools)),
-            });
-            Object.assign(tools, connectionTools);
-        }
-        const effectiveTools = marker ? applyLastToolCacheBreakpoint(tools, marker) : tools;
-        // --- Build hooks --------------------------------------------------------
-        const hooks = buildStepHooks({
-            cachePath,
-            emit,
-            emissionState,
-            marker,
-            session,
-        });
         // --- Execute via ToolLoopAgent ------------------------------------------
         /*
          * The `onError` override suppresses the AI SDK's default
@@ -321,146 +331,215 @@ export function createToolLoopHarness(config) {
                 }
             }
         }
-        const instructions = systemMessages.length > 0
-            ? [
-                ...(session.agent.system
-                    ? [{ role: "system", content: session.agent.system }]
-                    : []),
-                ...systemMessages,
-            ]
-            : session.agent.system || undefined;
-        const agentSettings = {
-            headers: attributionHeaders,
-            instructions,
-            model,
-            onError() { },
-            onStepFinish: hooks.onStepFinish,
-            prepareStep: hooks.prepareStep,
-            runtimeContext: buildTelemetryRuntimeContext(telemetryConfig, session),
-            stopWhen: isStepCount(1),
-            telemetry: enrichTelemetry(telemetryConfig, agentName),
-            tools: effectiveTools,
-        };
-        const agent = new ToolLoopAgent(agentSettings);
         const modelMessages = nonSystemMessages;
-        let result;
-        const executeModelCall = async () => {
-            if (emit) {
-                const streamResult = await agent.stream({ messages: modelMessages });
-                const { inlineActionResultCallIds, inlineToolResultParts } = await emitStreamContent(emit, emissionState, streamResult.fullStream);
-                const stepResult = await hooks.stepResult;
-                await emitStepActions(emit, emissionState, stepResult, {
-                    excludedActionToolNames: new Set([ASK_QUESTION_TOOL_NAME]),
-                    inlineActionResultCallIds,
-                    tools: config.tools,
+        /**
+         * Assembles the effective toolset, instructions, and ToolLoopAgent
+         * for one attempt of this step, then runs the model call.
+         *
+         * Called twice in the recovery path: once for the original attempt
+         * with full tools, and once after the gateway rejects a
+         * provider-specific tool — the retry passes `disabledProviderTools`
+         * to drop the offending tool and `extraSystemNote` to tell the
+         * model why a capability was removed.
+         */
+        const runOneModelCall = async (opts) => {
+            const tools = await buildToolSetWithProviderTools({
+                approvedTools,
+                capabilities: config.capabilities,
+                disabledProviderTools: opts.disabledProviderTools,
+                modelReference: session.agent.modelReference,
+                tools: config.tools,
+            });
+            if (registry !== undefined && discovered !== undefined) {
+                const connectionTools = await resolveConnectionToolsFromState(registry, discovered, {
+                    approvedTools,
+                    existingToolNames: new Set(Object.keys(tools)),
                 });
-                if (inlineToolResultParts.length > 0) {
-                    /*
-                     * AI SDK `StepResult` is a class whose `content`,
-                     * `toolCalls`, `toolResults`, `text` are prototype getters.
-                     * Each field is read explicitly here rather than via spread
-                     * so the returned plain object carries the values — spread
-                     * would copy only own enumerable properties and the
-                     * downstream `extractQuestionInputRequests` would crash on
-                     * `toolCalls === undefined`.
-                     */
-                    return {
-                        content: stepResult.content,
-                        finishReason: stepResult.finishReason,
-                        response: {
-                            ...stepResult.response,
-                            messages: [
-                                { role: "tool", content: [...inlineToolResultParts] },
-                                ...stepResult.response.messages,
-                            ],
-                        },
-                        text: stepResult.text,
-                        toolCalls: stepResult.toolCalls,
-                        toolResults: stepResult.toolResults,
-                        usage: stepResult.usage,
-                    };
-                }
-                return stepResult;
+                Object.assign(tools, connectionTools);
             }
-            await agent.generate({ messages: modelMessages });
-            return await hooks.stepResult;
-        };
-        try {
-            result = await runModelCallWithRetries(executeModelCall, {
+            const effectiveTools = marker ? applyLastToolCacheBreakpoint(tools, marker) : tools;
+            // Pin gateway routing to the provider that owns any
+            // provider-specific tool in this step's toolset. Converts a
+            // transient primary outage into a retryable 503 instead of
+            // routing to an incompatible fallback provider. Skipped on the
+            // recovery retry because the offending tool was dropped — any
+            // provider can serve the request now.
+            const gatewayPinProvider = resolveGatewayPinForStep({
+                cachePath,
+                modelReference: session.agent.modelReference,
+                tools: effectiveTools,
+            });
+            // Build instructions, optionally prepending the recovery
+            // system note so the model sees one explicit signal that a
+            // capability was removed for this attempt.
+            const extraSystemEntry = opts.extraSystemNote
+                ? [{ role: "system", content: opts.extraSystemNote }]
+                : [];
+            const baseSystemEntry = session.agent.system
+                ? [{ role: "system", content: session.agent.system }]
+                : [];
+            const instructions = systemMessages.length > 0 || extraSystemEntry.length > 0
+                ? [...extraSystemEntry, ...baseSystemEntry, ...systemMessages]
+                : session.agent.system || undefined;
+            const hooks = buildStepHooks({
+                cachePath,
+                emit,
+                emissionState,
+                emitStepStarted: opts.suppressStepStartedEmission !== true,
+                gatewayPinProvider,
+                marker,
+                session,
+            });
+            const agentSettings = {
+                headers: attributionHeaders,
+                instructions,
+                model,
+                onError() { },
+                onStepFinish: hooks.onStepFinish,
+                prepareStep: hooks.prepareStep,
+                runtimeContext: buildTelemetryRuntimeContext(telemetryConfig, session),
+                stopWhen: isStepCount(1),
+                telemetry: enrichTelemetry(telemetryConfig, agentName),
+                tools: effectiveTools,
+            };
+            const agent = new ToolLoopAgent(agentSettings);
+            const executeModelCall = async () => {
+                if (emit) {
+                    const streamResult = await agent.stream({ messages: modelMessages });
+                    const { inlineActionResultCallIds, inlineToolResultParts } = await emitStreamContent(emit, emissionState, streamResult.fullStream);
+                    const stepResult = await hooks.stepResult;
+                    await emitStepActions(emit, emissionState, stepResult, {
+                        excludedActionToolNames: new Set([ASK_QUESTION_TOOL_NAME]),
+                        inlineActionResultCallIds,
+                        tools: config.tools,
+                    });
+                    if (inlineToolResultParts.length > 0) {
+                        /*
+                         * AI SDK `StepResult` is a class whose `content`,
+                         * `toolCalls`, `toolResults`, `text` are prototype getters.
+                         * Each field is read explicitly here rather than via spread
+                         * so the returned plain object carries the values — spread
+                         * would copy only own enumerable properties and the
+                         * downstream `extractQuestionInputRequests` would crash on
+                         * `toolCalls === undefined`.
+                         */
+                        return {
+                            content: stepResult.content,
+                            finishReason: stepResult.finishReason,
+                            response: {
+                                ...stepResult.response,
+                                messages: [
+                                    { role: "tool", content: [...inlineToolResultParts] },
+                                    ...stepResult.response.messages,
+                                ],
+                            },
+                            text: stepResult.text,
+                            toolCalls: stepResult.toolCalls,
+                            toolResults: stepResult.toolResults,
+                            usage: stepResult.usage,
+                        };
+                    }
+                    return stepResult;
+                }
+                await agent.generate({ messages: modelMessages });
+                return await hooks.stepResult;
+            };
+            return runModelCallWithRetries(executeModelCall, {
                 sessionId: session.sessionId,
                 turnId: emissionState.turnId,
             });
+        };
+        let result;
+        try {
+            result = await runOneModelCall({});
         }
         catch (error) {
-            // Surface the full cause chain + upstream responseBody to OTel
-            // via the turn span. The AI SDK's automatic
-            // `span.recordException(err)` on its own `ai.streamText` span
-            // only captures `error.stack` and does not traverse `cause`,
-            // so the gateway-wrapped upstream 4xx body would otherwise be
-            // invisible to OTel providers.
-            if (turnSpan) {
-                recordErrorOnSpan(turnSpan, error);
-            }
-            if (!emit) {
-                // Internal harness callers without an emit fn (tests, task-only
-                // code paths) get the raw throw. Only runtime-connected harness
-                // calls go through the structured failure path below.
-                throw error;
-            }
-            const classification = classifyModelCallError(error);
-            const errorId = createErrorId();
-            const configSummary = classification === "terminal" ? summarizeKnownModelCallConfigError(error) : null;
-            const requestSummary = configSummary === null ? summarizeKnownModelCallRequestError(error) : null;
-            const errorMessage = configSummary?.message ?? requestSummary?.message ?? toErrorMessage(error);
-            const modelCallDetails = extractModelCallErrorDetails(error);
-            const details = buildModelCallFailureDetails({
-                configSummary,
+            // First, try to recover by dropping any provider-specific tool
+            // that the AI Gateway's fallback provider rejected. This converts
+            // the otherwise-terminal failure into one extra model call with a
+            // degraded toolset — the agent's turn proceeds without the
+            // capability the chosen provider could not serve.
+            const recoveryResult = await attemptUnsupportedProviderToolRecovery({
                 error,
-                errorId,
-                modelCallDetails,
-                requestSummary,
-            });
-            const modelCallLogFields = buildModelCallFailureLogFields({
-                error,
-                errorId,
-                modelCallDetails,
-                requestSummary,
+                runOneModelCall,
                 sessionId: session.sessionId,
                 turnId: emissionState.turnId,
             });
-            if (classification === "terminal") {
-                if (configSummary !== null) {
-                    // Recognized configuration failure: log a concise single line
-                    // and skip the structured SDK dump so the user sees an
-                    // actionable hint instead of a wall of inspector output.
-                    log.error(`${configSummary.name}: ${configSummary.message}`, {
-                        errorId,
+            if (recoveryResult.outcome === "recovered") {
+                result = recoveryResult.result;
+            }
+            else {
+                // Surface the full cause chain + upstream responseBody to OTel
+                // via the turn span. The AI SDK's automatic
+                // `span.recordException(err)` on its own `ai.streamText` span
+                // only captures `error.stack` and does not traverse `cause`,
+                // so the gateway-wrapped upstream 4xx body would otherwise be
+                // invisible to OTel providers.
+                const finalError = recoveryResult.error;
+                if (turnSpan) {
+                    recordErrorOnSpan(turnSpan, finalError);
+                }
+                if (!emit) {
+                    // Internal harness callers without an emit fn (tests, task-only
+                    // code paths) get the raw throw. Only runtime-connected harness
+                    // calls go through the structured failure path below.
+                    throw finalError;
+                }
+                const classification = classifyModelCallError(finalError);
+                const errorId = createErrorId();
+                const configSummary = classification === "terminal" ? summarizeKnownModelCallConfigError(finalError) : null;
+                const requestSummary = configSummary === null ? summarizeKnownModelCallRequestError(finalError) : null;
+                const errorMessage = configSummary?.message ?? requestSummary?.message ?? toErrorMessage(finalError);
+                const modelCallDetails = extractModelCallErrorDetails(finalError);
+                const details = buildModelCallFailureDetails({
+                    configSummary,
+                    error: finalError,
+                    errorId,
+                    modelCallDetails,
+                    requestSummary,
+                });
+                const modelCallLogFields = buildModelCallFailureLogFields({
+                    error: finalError,
+                    errorId,
+                    modelCallDetails,
+                    requestSummary,
+                    sessionId: session.sessionId,
+                    turnId: emissionState.turnId,
+                });
+                if (classification === "terminal") {
+                    if (configSummary !== null) {
+                        // Recognized configuration failure: log a concise single line
+                        // and skip the structured SDK dump so the user sees an
+                        // actionable hint instead of a wall of inspector output.
+                        log.error(`${configSummary.name}: ${configSummary.message}`, {
+                            errorId,
+                            sessionId: session.sessionId,
+                            turnId: emissionState.turnId,
+                        });
+                    }
+                    else {
+                        log.error(requestSummary?.message ?? "model call failed terminally", modelCallLogFields);
+                    }
+                    await emitFailedStep(emit, emissionState, {
+                        code: "MODEL_CALL_FAILED",
+                        details,
+                        message: errorMessage,
                         sessionId: session.sessionId,
-                        turnId: emissionState.turnId,
                     });
+                    return {
+                        next: { done: true, output: "" },
+                        session,
+                    };
                 }
-                else {
-                    log.error(requestSummary?.message ?? "model call failed terminally", modelCallLogFields);
-                }
-                await emitFailedStep(emit, emissionState, {
+                log.error(requestSummary?.message ?? "model call failed — parking session for retry by the user", modelCallLogFields);
+                emissionState = await emitRecoverableFailedTurn(emit, emissionState, {
                     code: "MODEL_CALL_FAILED",
                     details,
                     message: errorMessage,
-                    sessionId: session.sessionId,
                 });
-                return {
-                    next: { done: true, output: "" },
-                    session,
-                };
+                const parkedSession = setHarnessEmissionState(session, emissionState);
+                return { next: null, session: parkedSession };
             }
-            log.error(requestSummary?.message ?? "model call failed — parking session for retry by the user", modelCallLogFields);
-            emissionState = await emitRecoverableFailedTurn(emit, emissionState, {
-                code: "MODEL_CALL_FAILED",
-                details,
-                message: errorMessage,
-            });
-            const parkedSession = setHarnessEmissionState(session, emissionState);
-            return { next: null, session: parkedSession };
         }
         // --- Handle result ------------------------------------------------------
         return handleStepResult({
@@ -533,6 +612,68 @@ function buildModelCallFailureLogFields(input) {
     }
     return { ...base, error: input.error };
 }
+/**
+ * Inspects a model-call failure for the "tool type 'X' is not supported"
+ * provider-attempt rejection that AI Gateway returns when a fallback
+ * provider cannot serve a provider-specific tool. On a match, retries the
+ * step once with the offending tool dropped and a one-shot system note
+ * telling the model which capability has been removed.
+ *
+ * Returns `recovered` when the retry succeeded so the caller can hand
+ * the result off to the usual post-step handler. Returns `failed`
+ * (with the original error, or the retry's error if the retry also
+ * threw) otherwise so the caller's existing terminal/recoverable
+ * cascade still runs.
+ *
+ * Recovery is intentionally scoped to known provider tools — entries in
+ * {@link UPSTREAM_TOOL_TYPE_TO_FRAMEWORK_NAME} — so an unrelated
+ * upstream rejection cannot accidentally drop a user-authored tool.
+ */
+async function attemptUnsupportedProviderToolRecovery(input) {
+    const unsupportedTypes = extractUnsupportedProviderToolTypes(input.error);
+    if (unsupportedTypes.length === 0) {
+        return { outcome: "failed", error: input.error };
+    }
+    const toolsToDisable = [];
+    for (const type of unsupportedTypes) {
+        const frameworkName = resolveFrameworkToolFromUpstreamType(type);
+        if (frameworkName !== null && !toolsToDisable.includes(frameworkName)) {
+            toolsToDisable.push(frameworkName);
+        }
+    }
+    if (toolsToDisable.length === 0) {
+        return { outcome: "failed", error: input.error };
+    }
+    log.warn("disabling unsupported provider tool(s); retrying step once", {
+        disabled: toolsToDisable,
+        sessionId: input.sessionId,
+        turnId: input.turnId,
+        upstreamTypes: unsupportedTypes,
+    });
+    try {
+        const result = await input.runOneModelCall({
+            disabledProviderTools: new Set(toolsToDisable),
+            extraSystemNote: buildDisabledToolNote(toolsToDisable),
+            suppressStepStartedEmission: true,
+        });
+        return { outcome: "recovered", result };
+    }
+    catch (retryError) {
+        return { outcome: "failed", error: retryError };
+    }
+}
+/**
+ * Builds the one-shot system note prepended to the recovery retry's
+ * instructions so the model has explicit context for why a capability
+ * disappeared mid-turn.
+ */
+function buildDisabledToolNote(toolNames) {
+    const list = toolNames.join(", ");
+    const noun = toolNames.length === 1 ? "tool is" : "tools are";
+    return (`The following ${noun} not available with the current model and ` +
+        `has been removed: ${list}. Proceed using the remaining tools or your ` +
+        `training knowledge.`);
+}
 // ---------------------------------------------------------------------------
 // Post-step result handling
 // ---------------------------------------------------------------------------

package/dist/src/harness/tools.d.ts

@@ -12,10 +12,16 @@ import type { HarnessToolMap } from "#harness/types.js";
  * {@link SessionCapabilities.requestInput} is `true`. Sessions without
  * the HITL capability (scheduled task roots and any subagent chain
  * descending from one) never see the tool.
+ *
+ * Entries listed in `disabledProviderTools` are skipped entirely. Used
+ * by the harness recovery path when a gateway fallback provider has
+ * rejected a provider-specific tool — the tool is dropped for the
+ * retry call so the request can proceed without it.
  */
 export declare function buildToolSet(input: {
     readonly approvedTools?: ReadonlySet<string>;
     readonly capabilities?: SessionCapabilities;
+    readonly disabledProviderTools?: ReadonlySet<string>;
     readonly tools: HarnessToolMap;
 }): ToolSet;
 /**
@@ -29,10 +35,16 @@ export declare function buildToolSet(input: {
  * When a user overrides a provider-managed tool via `defineTool()`, their
  * tool has a real executor and flows through the normal path — no
  * replacement occurs.
+ *
+ * Tool names listed in `disabledProviderTools` are skipped entirely —
+ * both the framework definition and the injected provider tool are
+ * omitted from the returned set. Used by the harness recovery path when
+ * a gateway fallback provider has rejected a provider-specific tool.
  */
 export declare function buildToolSetWithProviderTools(input: {
     readonly approvedTools?: ReadonlySet<string>;
     readonly capabilities?: SessionCapabilities;
+    readonly disabledProviderTools?: ReadonlySet<string>;
     readonly modelReference: RuntimeModelReference;
     readonly tools: HarnessToolMap;
 }): Promise<ToolSet>;

package/dist/src/harness/tools.js

@@ -13,14 +13,23 @@ import { resolveWebSearchBackend, resolveWebSearchProviderTool } from "#harness/
  * {@link SessionCapabilities.requestInput} is `true`. Sessions without
  * the HITL capability (scheduled task roots and any subagent chain
  * descending from one) never see the tool.
+ *
+ * Entries listed in `disabledProviderTools` are skipped entirely. Used
+ * by the harness recovery path when a gateway fallback provider has
+ * rejected a provider-specific tool — the tool is dropped for the
+ * retry call so the request can proceed without it.
  */
 export function buildToolSet(input) {
     const tools = {};
     const canRequestInput = input.capabilities?.requestInput === true;
+    const disabled = input.disabledProviderTools;
     for (const definition of input.tools.values()) {
         if (definition.name === ASK_QUESTION_TOOL_NAME && !canRequestInput) {
             continue;
         }
+        if (disabled?.has(definition.name)) {
+            continue;
+        }
         tools[definition.name] = tool({
             description: definition.description,
             execute: definition.execute,
@@ -46,22 +55,31 @@ export function buildToolSet(input) {
  * When a user overrides a provider-managed tool via `defineTool()`, their
  * tool has a real executor and flows through the normal path — no
  * replacement occurs.
+ *
+ * Tool names listed in `disabledProviderTools` are skipped entirely —
+ * both the framework definition and the injected provider tool are
+ * omitted from the returned set. Used by the harness recovery path when
+ * a gateway fallback provider has rejected a provider-specific tool.
  */
 export async function buildToolSetWithProviderTools(input) {
+    const disabled = input.disabledProviderTools;
     const tools = {
         ...buildToolSet({
             approvedTools: input.approvedTools,
             capabilities: input.capabilities,
+            disabledProviderTools: disabled,
             tools: input.tools,
         }),
     };
     // Inject the real provider tool for web_search when the definition has
     // no local execute (i.e. the framework definition uses the provider sentinel).
-    const webSearchTool = input.tools.get(WEB_SEARCH_TOOL_DEFINITION.name);
-    if (webSearchTool !== undefined && webSearchTool.execute === undefined) {
-        const backend = resolveWebSearchBackend(input.modelReference);
-        if (backend !== null) {
-            tools[WEB_SEARCH_TOOL_DEFINITION.name] = await resolveWebSearchProviderTool(backend);
+    if (!disabled?.has(WEB_SEARCH_TOOL_DEFINITION.name)) {
+        const webSearchTool = input.tools.get(WEB_SEARCH_TOOL_DEFINITION.name);
+        if (webSearchTool !== undefined && webSearchTool.execute === undefined) {
+            const backend = resolveWebSearchBackend(input.modelReference);
+            if (backend !== null) {
+                tools[WEB_SEARCH_TOOL_DEFINITION.name] = await resolveWebSearchProviderTool(backend);
+            }
         }
     }
     return tools;

package/dist/src/internal/application/package.js

@@ -6,7 +6,7 @@ import { ASH_PACKAGE_NAME } from "#package-name.js";
 let cachedPackageInfo;
 // The package build stamps the published version into `dist` so bundled
 // deployments can still report package metadata without resolving package.json.
-const BUNDLED_FALLBACK_PACKAGE_VERSION = "0.22.0";
+const BUNDLED_FALLBACK_PACKAGE_VERSION = "0.22.2";
 const BUNDLED_FALLBACK_PACKAGE_VERSION_PLACEHOLDER = "__ASH_PACKAGE_VERSION_PLACEHOLDER__";
 const WORKFLOW_MODULE_ALIASES = {
     "workflow/api": "src/compiled/@workflow/core/runtime.js",