@juspay/neurolink 10.5.2 → 10.6.0

package/dist/lib/models/modelRegistry.d.ts

@@ -33,6 +33,29 @@ export declare function getModelById(id: string): ModelInfo | undefined;
  * custom models retain the existing behavior until capability data is added.
  */
 export declare function modelSupports(capability: keyof ModelCapabilities, provider: string, model: string): boolean;
+/**
+ * Whether a model accepts classic sampling parameters
+ * (`temperature` / `topP`).
+ *
+ * Resolution order: an explicit `capabilities.samplingParams` on a matching
+ * registry entry wins; otherwise the known rejecting-family patterns decide.
+ * Unknown models default to supported (same fail-open contract as
+ * `modelSupports`). Providers strip the parameters — including on
+ * retry/fallback request rebuilds — when this returns false.
+ */
+export declare function modelSupportsSamplingParams(provider: string, model: string | undefined): boolean;
+/**
+ * Sampling params to actually send for a model: passthrough when supported,
+ * `{}` (with a debug log) when the model rejects them. Apply at every
+ * request-build site, including retry/fallback rebuilds.
+ */
+export declare function resolveSamplingParams(provider: string, model: string | undefined, params: {
+    temperature?: number;
+    topP?: number;
+}, site: string): {
+    temperature?: number;
+    topP?: number;
+};
 /**
  * Get models by provider
  */

package/dist/lib/models/modelRegistry.js

@@ -4,6 +4,7 @@
  * Part of Phase 4.1 - Models Command System
  */
 import { DEFAULT_MODEL_ALIASES } from "../types/index.js";
+import { logger } from "../utils/logger.js";
 import { AIProviderName, OpenAIModels, AzureOpenAIModels, GoogleAIModels, AnthropicModels, BedrockModels, MistralModels, OllamaModels, } from "../constants/enums.js";
 /**
  * Comprehensive model registry
@@ -2356,7 +2357,67 @@ export function modelSupports(capability, provider, model) {
     if (!modelInfo || modelInfo.provider !== provider.toLowerCase()) {
         return true;
     }
-    return modelInfo.capabilities[capability];
+    // Optional capabilities (e.g. samplingParams) default to supported.
+    return modelInfo.capabilities[capability] ?? true;
+}
+/**
+ * Model families known to reject classic sampling parameters
+ * (`temperature` / `topP`) in favour of reasoning-effort controls:
+ * Claude Sonnet 5, Opus 4.7+ (including Opus 5), and the Fable/Mythos 5
+ * tier — notably as served through Vertex. Kept as patterns because gateway
+ * model ids carry arbitrary prefixes/suffixes
+ * (`vertex_ai/claude-sonnet-5@20260203`) that exact registry ids can't cover.
+ */
+const SAMPLING_PARAM_REJECTING_FAMILIES = [
+    /sonnet[-_.]?5(?![0-9])/i,
+    /opus[-_.]?4[-_.]?(?:[7-9]|\d{2,})(?![0-9])/i,
+    /opus[-_.]?5(?![0-9])/i,
+    /fable/i,
+    /mythos/i,
+];
+/**
+ * Whether a model accepts classic sampling parameters
+ * (`temperature` / `topP`).
+ *
+ * Resolution order: an explicit `capabilities.samplingParams` on a matching
+ * registry entry wins; otherwise the known rejecting-family patterns decide.
+ * Unknown models default to supported (same fail-open contract as
+ * `modelSupports`). Providers strip the parameters — including on
+ * retry/fallback request rebuilds — when this returns false.
+ */
+export function modelSupportsSamplingParams(provider, model) {
+    const normalizedModel = (model ?? "").toLowerCase();
+    if (!normalizedModel) {
+        return true;
+    }
+    const modelId = MODEL_ALIASES[normalizedModel] ?? normalizedModel;
+    const modelInfo = MODEL_REGISTRY[modelId];
+    if (modelInfo &&
+        modelInfo.provider === provider.toLowerCase() &&
+        modelInfo.capabilities.samplingParams !== undefined) {
+        return modelInfo.capabilities.samplingParams;
+    }
+    return !SAMPLING_PARAM_REJECTING_FAMILIES.some((family) => family.test(modelId) || family.test(normalizedModel));
+}
+/**
+ * Sampling params to actually send for a model: passthrough when supported,
+ * `{}` (with a debug log) when the model rejects them. Apply at every
+ * request-build site, including retry/fallback rebuilds.
+ */
+export function resolveSamplingParams(provider, model, params, site) {
+    if (modelSupportsSamplingParams(provider, model)) {
+        return params;
+    }
+    if (params.temperature !== undefined || params.topP !== undefined) {
+        logger.debug(`[ModelRegistry] Stripping sampling params for ${provider}/${model} at ${site} — model rejects temperature/topP`, {
+            provider,
+            model,
+            site,
+            hadTemperature: params.temperature !== undefined,
+            hadTopP: params.topP !== undefined,
+        });
+    }
+    return {};
 }
 /**
  * Get models by provider

package/dist/lib/models/modelResolver.js

@@ -102,6 +102,7 @@ export class ModelResolver {
             multimodal: [],
             streaming: [],
             jsonMode: [],
+            samplingParams: [],
         };
         // Group models by capabilities
         for (const model of models) {

package/dist/lib/neurolink.d.ts

@@ -5,7 +5,7 @@
  * Enhanced AI provider system with natural MCP tool access.
  * Uses real MCP infrastructure for tool discovery and execution.
  */
-import type { AgentDefinition, AgentNetworkConfig, NetworkExecutionInput, NetworkExecutionOptions, NetworkExecutionResult, NetworkStreamChunk } from "./types/index.js";
+import type { AgentDefinition, AgentNetworkConfig, AgentRunOptions, AgentRunOutcome, AgentToolRegistrationOptions, IsolatedAgentDefinition, NetworkExecutionInput, NetworkExecutionOptions, NetworkExecutionResult, NetworkStreamChunk, WorkerInstanceOptions } from "./types/index.js";
 import type { CompactionConfig, CompactionResult, SpanData, ObservabilityConfig, MetricsSummary, MCPToolAnnotations, TraceView, AuthenticatedContext, AuthProvider, JsonObject, NeuroLinkEvents, TypedEventEmitter, MCPEnhancementsConfig, NeuroLinkAuthConfig, NeurolinkConstructorConfig, ChatMessage, ExternalMCPOperationResult, ExternalMCPServerInstance, ExternalMCPToolInfo, GenerateOptions, GenerateResult, ProviderStatus, TextGenerationOptions, TextGenerationResult, MCPExecutableTool, MCPServerInfo, MCPStatus, StreamOptions, StreamResult, ToolExecutionContext, ToolExecutionSummary, ToolInfo, ToolRegistrationOptions, BatchOperationResult, StreamGenerationEndContext, ToolRoutingServerDescriptor, ToolDedupConfig, ToolConfig, KnowledgeEngineStatus } from "./types/index.js";
 import { ConversationMemoryManager } from "./core/conversationMemoryManager.js";
 import type { RedisConversationMemoryManager } from "./core/redisConversationMemoryManager.js";
@@ -169,6 +169,11 @@ export declare class NeuroLink {
      * This context will be merged with any runtime context passed by the AI model
      */
     private toolExecutionContext?;
+    /**
+     * Set when registerAgentTool() has registered at least one delegation
+     * tool — gates the per-turn delegation scope in generate().
+     */
+    private hasAgentTools;
     /**
      * Creates a new NeuroLink instance for AI text generation with MCP tool integration.
      *
@@ -2419,6 +2424,80 @@ export declare class NeuroLink {
      * @since 8.38.0
      */
     createNetwork(config: AgentNetworkConfig): Promise<import("./agent/agentNetwork.js").AgentNetwork>;
+    /**
+     * Create a worker-mode NeuroLink instance for sub-agent execution.
+     *
+     * Worker mode is the framework-provided version of the config block every
+     * consumer used to copy by hand: conversation memory OFF, orchestration
+     * OFF, observability inherited from this instance with
+     * `autoDetectExternalProvider: true` + `skipLangfuseSpanProcessor: true`
+     * (worker spans join the host's tracer without duplicate Langfuse
+     * exports), credentials inherited, the host's tool registry shared (so
+     * worker tool calls reuse the host's connections), and an internal log
+     * bridge attached with a caller-supplied tag.
+     *
+     * Dispose the worker (`worker.dispose()`) when done — `runIsolatedAgent`
+     * does this automatically in a `finally`.
+     *
+     * @param options - Worker options (log tag/sink, registry sharing, config)
+     * @returns A new worker-mode NeuroLink instance
+     * @see {@link WorkerInstanceOptions}
+     */
+    createWorkerInstance(options?: WorkerInstanceOptions): NeuroLink;
+    /**
+     * Run an isolated sub-agent: a worker instance (see
+     * {@link createWorkerInstance}) executes a tool-using research pass under
+     * the turn budget (wrap-up nudge, stall watchdog, honest `stopReason`),
+     * then an extraction pass ALWAYS runs tools-off on its own timeout with a
+     * structured-recovery ladder and corrective re-asks. A non-empty execution
+     * record never produces an empty result (mechanical digest fallback), a
+     * parent `abortSignal` stops everything cleanly, and `options.leg` enables
+     * leashed mode with TTL'd resume handles ({@link continueAgent} /
+     * {@link stopAgent}).
+     *
+     * @param definition - Agent definition (+ optional structured extraction)
+     * @param input - Task input: string or structured object
+     * @param options - Run options (abort, overrides, tool context, events, leg)
+     * @returns The run outcome
+     * @see {@link IsolatedAgentDefinition}
+     * @see {@link AgentRunOptions}
+     * @see {@link AgentRunOutcome}
+     */
+    runIsolatedAgent(definition: IsolatedAgentDefinition, input: string | Record<string, unknown>, options?: AgentRunOptions): Promise<AgentRunOutcome>;
+    /**
+     * Resume a leashed isolated-agent run by handle. `guidance`, when given,
+     * is appended as a user turn before the next leg — the supervisor's
+     * re-steering channel. An expired handle returns its tombstoned final
+     * outcome exactly once.
+     *
+     * @param handle - Handle from an `in_progress` {@link AgentRunOutcome}
+     * @param guidance - Optional supervisor guidance for the next leg
+     * @returns The next leg's outcome (or the final outcome)
+     */
+    continueAgent(handle: string, guidance?: string): Promise<AgentRunOutcome>;
+    /**
+     * Stop a leashed isolated-agent run: dispose its worker and return the
+     * final outcome (mechanical digest over everything gathered so far).
+     *
+     * @param handle - Handle from an `in_progress` {@link AgentRunOutcome}
+     * @returns The final outcome
+     */
+    stopAgent(handle: string): Promise<AgentRunOutcome>;
+    /**
+     * Register an isolated agent as a delegation tool on THIS instance, so
+     * its existing generate() loop can delegate — no second router generate.
+     * Framework policy (per-turn caps, depth withholding, a process-wide
+     * concurrency pool with queue timeout) is enforced in the loop itself,
+     * and every refusal carries its recovery instruction in the error text.
+     *
+     * @param definition - Agent definition (+ optional structured extraction)
+     * @param options - Registration options (name, caps, depth, pool, leg)
+     * @returns The registered tool name
+     * @see {@link AgentToolRegistrationOptions}
+     */
+    registerAgentTool(definition: IsolatedAgentDefinition, options?: AgentToolRegistrationOptions): Promise<{
+        name: string;
+    }>;
     /**
      * Execute an agent network with the given input.
      *

package/dist/lib/neurolink.js

@@ -92,7 +92,8 @@ import { directAgentTools } from "./agent/directTools.js";
 import { BinaryTaskClassifier } from "./utils/taskClassifier.js";
 // Tool detection and execution imports
 // Transformation utilities
-import { extractToolNames, optimizeToolForCollection, transformAvailableTools, transformParamsForLogging, transformToolExecutions, transformToolExecutionsForMCP, transformToolsForMCP, transformToolsToDescriptions, transformToolsToExpectedFormat, } from "./utils/transformationUtils.js";
+import { extractToolNames, optimizeToolForCollection, transformAvailableTools, transformParamsForLogging, transformToolExecutionsForMCP, transformToolsForMCP, transformToolsToDescriptions, transformToolsToExpectedFormat, } from "./utils/transformationUtils.js";
+import { toToolExecutionRecords } from "./core/toolExecutionRecorder.js";
 import { isNonNullObject } from "./utils/typeUtils.js";
 import { getWorkflow } from "./workflow/core/workflowRegistry.js";
 import { runWorkflow } from "./workflow/core/workflowRunner.js";
@@ -755,6 +756,11 @@ export class NeuroLink {
      * This context will be merged with any runtime context passed by the AI model
      */
     toolExecutionContext;
+    /**
+     * Set when registerAgentTool() has registered at least one delegation
+     * tool — gates the per-turn delegation scope in generate().
+     */
+    hasAgentTools = false;
     /**
      * Creates a new NeuroLink instance for AI text generation with MCP tool integration.
      *
@@ -3142,6 +3148,18 @@ Current user's request: ${currentInput}`;
      * @since 1.0.0
      */
     async generate(optionsOrPrompt) {
+        // Host-loop delegation (registerAgentTool): enter a per-turn scope so
+        // delegation caps count against THIS top-level generate, and withhold
+        // depth-limited agent tools from the request. beginDelegationTurn
+        // returns null when a scope is already active, so the re-entrant call
+        // below proceeds through the normal body sharing the turn's counters.
+        if (this.hasAgentTools) {
+            const { beginDelegationTurn } = await import("./agent/agentToolRegistrar.js");
+            const scope = beginDelegationTurn(this, optionsOrPrompt);
+            if (scope) {
+                return scope.run(() => this.generate(scope.options));
+            }
+        }
         // Defensive call-isolation clone — mirrors stream(): downstream
         // generate-prep (memory retrieval, orchestration, RAG/MCP tool
         // injection) mutates nested branches on the caller-supplied options
@@ -4112,7 +4130,7 @@ Current user's request: ${currentInput}`;
                 : undefined,
             responseTime: textResult.responseTime,
             toolsUsed: textResult.toolsUsed,
-            toolExecutions: transformToolExecutions(textResult.toolExecutions),
+            toolExecutions: toToolExecutionRecords(textResult.toolExecutions),
             enhancedWithTools: textResult.enhancedWithTools,
             availableTools: transformAvailableTools(textResult.availableTools),
             analytics: textResult.analytics,
@@ -5720,21 +5738,16 @@ Current user's request: ${currentInput}`;
                         rawFinishReason: poolResult.rawFinishReason,
                         stepsUsed: poolResult.stepsUsed,
                         toolsUsed: poolResult.toolsUsed || [],
-                        toolExecutions: poolResult.toolExecutions?.map((te) => {
-                            const t = te;
-                            return {
-                                ...te,
-                                toolName: te.name,
-                                executionTime: typeof t.executionTime === "number"
-                                    ? t.executionTime
-                                    : typeof t.duration === "number"
-                                        ? t.duration
-                                        : 0,
-                                success: typeof t.success === "boolean"
-                                    ? t.success
-                                    : t.status === "success",
-                            };
-                        }),
+                        // Lossless pass-through: keep the full ToolExecutionRecord
+                        // fields (params/resultText/isError/timing) alongside the
+                        // legacy {toolName,executionTime,success} shape this internal
+                        // result declares, so the final GenerateResult mapping
+                        // reconstructs real records instead of empty ones.
+                        toolExecutions: poolResult.toolExecutions?.map((te) => ({
+                            ...te,
+                            executionTime: te.durationMs,
+                            success: !te.isError,
+                        })),
                         enhancedWithTools: !!poolResult.toolExecutions?.length,
                         analytics: poolResult.analytics,
                         evaluation: poolResult.evaluation,
@@ -6008,25 +6021,15 @@ Current user's request: ${currentInput}`;
                     rawFinishReason: result.rawFinishReason,
                     stepsUsed: result.stepsUsed,
                     toolsUsed: result.toolsUsed || [],
-                    // Map toolExecutions from EnhancedGenerateResult shape ({name,input,output})
-                    // to TextGenerationResult shape ({toolName,executionTime,success}).
-                    // Preserve original timing/status when present, fall back to safe defaults.
-                    toolExecutions: result.toolExecutions?.map((te) => {
-                        const t = te;
-                        return {
-                            // Spread original fields first so normalized fields take precedence
-                            ...te,
-                            toolName: te.name,
-                            executionTime: typeof t.executionTime === "number"
-                                ? t.executionTime
-                                : typeof t.duration === "number"
-                                    ? t.duration
-                                    : 0,
-                            success: typeof t.success === "boolean"
-                                ? t.success
-                                : t.status === "success",
-                        };
-                    }),
+                    // Lossless pass-through: keep the full ToolExecutionRecord fields
+                    // alongside the legacy {toolName,executionTime,success} shape this
+                    // internal result declares, so the final GenerateResult mapping
+                    // reconstructs real records instead of empty ones.
+                    toolExecutions: result.toolExecutions?.map((te) => ({
+                        ...te,
+                        executionTime: te.durationMs,
+                        success: !te.isError,
+                    })),
                     enhancedWithTools: !!result.toolExecutions?.length,
                     analytics: result.analytics,
                     evaluation: result.evaluation,
@@ -6277,6 +6280,19 @@ Current user's request: ${currentInput}`;
      * @throws {Error} When conversation memory operations fail (if enabled)
      */
     async stream(options) {
+        // Host-loop delegation (registerAgentTool): the same per-turn scope as
+        // generate() — delegation caps count against THIS streamed turn and
+        // depth-limited agent tools are withheld from the request. The provider
+        // stream loops start inside this call, so the ALS scope propagates into
+        // their tool executions. beginDelegationTurn returns null when a scope
+        // is already active (the re-entrant call below shares the counters).
+        if (this.hasAgentTools) {
+            const { beginDelegationTurn } = await import("./agent/agentToolRegistrar.js");
+            const scope = beginDelegationTurn(this, options);
+            if (scope) {
+                return scope.run(() => this.stream(scope.options));
+            }
+        }
         logger.debug("[NeuroLink] stream() called with options", {
             provider: options.provider,
             model: options.model,
@@ -12162,6 +12178,150 @@ Current user's request: ${currentInput}`;
         });
         return new AgentNetwork(config, this);
     }
+    /**
+     * Create a worker-mode NeuroLink instance for sub-agent execution.
+     *
+     * Worker mode is the framework-provided version of the config block every
+     * consumer used to copy by hand: conversation memory OFF, orchestration
+     * OFF, observability inherited from this instance with
+     * `autoDetectExternalProvider: true` + `skipLangfuseSpanProcessor: true`
+     * (worker spans join the host's tracer without duplicate Langfuse
+     * exports), credentials inherited, the host's tool registry shared (so
+     * worker tool calls reuse the host's connections), and an internal log
+     * bridge attached with a caller-supplied tag.
+     *
+     * Dispose the worker (`worker.dispose()`) when done — `runIsolatedAgent`
+     * does this automatically in a `finally`.
+     *
+     * @param options - Worker options (log tag/sink, registry sharing, config)
+     * @returns A new worker-mode NeuroLink instance
+     * @see {@link WorkerInstanceOptions}
+     */
+    createWorkerInstance(options) {
+        const tag = options?.logTag ?? "worker";
+        const hostEmitter = this.emitter;
+        const configOverrides = (options?.config ?? {});
+        const workerConfig = {
+            ...(this.credentials ? { credentials: this.credentials } : {}),
+            ...configOverrides,
+            // Worker-mode fields always win over the config merge.
+            conversationMemory: { enabled: false },
+            enableOrchestration: false,
+            observability: {
+                ...(this.observabilityConfig ?? {}),
+                langfuse: {
+                    ...(this.observabilityConfig?.langfuse ?? {}),
+                    autoDetectExternalProvider: true,
+                    skipLangfuseSpanProcessor: true,
+                },
+            },
+            ...(options?.shareToolRegistry !== false && {
+                toolRegistry: this.toolRegistry,
+            }),
+        };
+        const worker = new NeuroLink(workerConfig);
+        // Constructing an instance rebinds the process-global logger sink to the
+        // new instance's emitter — restore the host as the active sink so host
+        // log bridges keep flowing while workers come and go.
+        logger.setEventEmitter(hostEmitter);
+        if (options?.onLog) {
+            const onLog = options.onLog;
+            const forward = (raw) => {
+                try {
+                    const entry = (raw ?? {});
+                    onLog({
+                        tag,
+                        level: String(entry.level ?? "info"),
+                        message: String(entry.message ?? ""),
+                        timestamp: typeof entry.timestamp === "number"
+                            ? entry.timestamp
+                            : Date.now(),
+                        data: entry.data,
+                    });
+                }
+                catch {
+                    // Log-bridge listener errors never disrupt the worker.
+                }
+            };
+            hostEmitter.on("log-event", forward);
+            const originalDispose = worker.dispose.bind(worker);
+            worker.dispose = async () => {
+                hostEmitter.off("log-event", forward);
+                await originalDispose();
+            };
+        }
+        logger.debug("[NeuroLink] Created worker instance", {
+            tag,
+            sharedToolRegistry: options?.shareToolRegistry !== false,
+        });
+        return worker;
+    }
+    /**
+     * Run an isolated sub-agent: a worker instance (see
+     * {@link createWorkerInstance}) executes a tool-using research pass under
+     * the turn budget (wrap-up nudge, stall watchdog, honest `stopReason`),
+     * then an extraction pass ALWAYS runs tools-off on its own timeout with a
+     * structured-recovery ladder and corrective re-asks. A non-empty execution
+     * record never produces an empty result (mechanical digest fallback), a
+     * parent `abortSignal` stops everything cleanly, and `options.leg` enables
+     * leashed mode with TTL'd resume handles ({@link continueAgent} /
+     * {@link stopAgent}).
+     *
+     * @param definition - Agent definition (+ optional structured extraction)
+     * @param input - Task input: string or structured object
+     * @param options - Run options (abort, overrides, tool context, events, leg)
+     * @returns The run outcome
+     * @see {@link IsolatedAgentDefinition}
+     * @see {@link AgentRunOptions}
+     * @see {@link AgentRunOutcome}
+     */
+    async runIsolatedAgent(definition, input, options) {
+        const { runIsolatedAgent } = await import("./agent/isolatedAgentRunner.js");
+        return runIsolatedAgent(this, definition, input, options);
+    }
+    /**
+     * Resume a leashed isolated-agent run by handle. `guidance`, when given,
+     * is appended as a user turn before the next leg — the supervisor's
+     * re-steering channel. An expired handle returns its tombstoned final
+     * outcome exactly once.
+     *
+     * @param handle - Handle from an `in_progress` {@link AgentRunOutcome}
+     * @param guidance - Optional supervisor guidance for the next leg
+     * @returns The next leg's outcome (or the final outcome)
+     */
+    async continueAgent(handle, guidance) {
+        const { continueIsolatedAgent } = await import("./agent/isolatedAgentRunner.js");
+        return continueIsolatedAgent(this, handle, guidance);
+    }
+    /**
+     * Stop a leashed isolated-agent run: dispose its worker and return the
+     * final outcome (mechanical digest over everything gathered so far).
+     *
+     * @param handle - Handle from an `in_progress` {@link AgentRunOutcome}
+     * @returns The final outcome
+     */
+    async stopAgent(handle) {
+        const { stopIsolatedAgent } = await import("./agent/isolatedAgentRunner.js");
+        return stopIsolatedAgent(this, handle);
+    }
+    /**
+     * Register an isolated agent as a delegation tool on THIS instance, so
+     * its existing generate() loop can delegate — no second router generate.
+     * Framework policy (per-turn caps, depth withholding, a process-wide
+     * concurrency pool with queue timeout) is enforced in the loop itself,
+     * and every refusal carries its recovery instruction in the error text.
+     *
+     * @param definition - Agent definition (+ optional structured extraction)
+     * @param options - Registration options (name, caps, depth, pool, leg)
+     * @returns The registered tool name
+     * @see {@link AgentToolRegistrationOptions}
+     */
+    async registerAgentTool(definition, options) {
+        const { registerAgentTool } = await import("./agent/agentToolRegistrar.js");
+        const registered = registerAgentTool(this, definition, options);
+        this.hasAgentTools = true;
+        return registered;
+    }
     /**
      * Execute an agent network with the given input.
      *
@@ -12293,7 +12453,9 @@ Current user's request: ${currentInput}`;
                 try {
                     logger.debug("[NeuroLink] Removing all event listeners...");
                     this.emitter.removeAllListeners();
-                    logger.clearEventEmitter();
+                    // Clear only if this instance's emitter is the active log sink —
+                    // disposing a worker instance must not yank the host's bridge.
+                    logger.clearEventEmitter(this.emitter);
                     logger.debug("[NeuroLink] Event listeners removed successfully");
                 }
                 catch (error) {

package/dist/lib/providers/amazonBedrock.js

@@ -10,6 +10,7 @@ import { AuthenticationError, ProviderError, RateLimitError, } from "../types/in
 import { isAbortError, withTimeout } from "../utils/errorHandling.js";
 import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
 import { logger } from "../utils/logger.js";
+import { resolveSamplingParams } from "../models/modelRegistry.js";
 import { calculateCost } from "../utils/pricing.js";
 import { buildMultimodalMessagesArray } from "../utils/messageBuilder.js";
 import { buildMultimodalOptions } from "../utils/multimodalOptionsBuilder.js";
@@ -322,6 +323,10 @@ export class AmazonBedrockProvider extends BaseProvider {
                 const aiTools = await this.getAllTools();
                 const allTools = this.convertAISDKToolsToToolDefinitions(aiTools);
                 const toolConfig = this.formatToolsForBedrock(allTools);
+                // Registry-driven strip: models that reject sampling params
+                // (Sonnet 5 / Opus 4.7+ / Fable 5 Claude families on Bedrock)
+                // must not receive the legacy 0.7 default temperature.
+                const generateSampling = resolveSamplingParams(this.providerName, this.modelName || this.getDefaultModel(), { temperature: options.temperature ?? 0.7 }, "bedrock.converse");
                 const commandInput = {
                     modelId: this.modelName || this.getDefaultModel(),
                     messages: this.convertToAWSMessages(this.conversationHistory),
@@ -333,7 +338,9 @@ export class AmazonBedrockProvider extends BaseProvider {
                     ],
                     inferenceConfig: {
                         maxTokens: options.maxTokens, // No default limit - unlimited unless specified
-                        temperature: options.temperature || 0.7,
+                        ...(generateSampling.temperature !== undefined && {
+                            temperature: generateSampling.temperature,
+                        }),
                     },
                 };
                 if (toolConfig) {
@@ -1324,6 +1331,10 @@ export class AmazonBedrockProvider extends BaseProvider {
                 logger.debug(`[AmazonBedrockProvider] Converted Message ${index}: role=${msg.role}, content=${JSON.stringify(msg.content)}`);
             });
         }
+        // Registry-driven strip: models that reject sampling params (Sonnet 5 /
+        // Opus 4.7+ / Fable 5 Claude families on Bedrock) must not receive the
+        // legacy 0.7 default temperature.
+        const streamSampling = resolveSamplingParams(this.providerName, this.modelName || this.getDefaultModel(), { temperature: options.temperature ?? 0.7 }, "bedrock.converseStream");
         const commandInput = {
             modelId: this.modelName || this.getDefaultModel(),
             messages: convertedMessages,
@@ -1335,7 +1346,9 @@ export class AmazonBedrockProvider extends BaseProvider {
             ],
             inferenceConfig: {
                 maxTokens: options.maxTokens, // No default limit - unlimited unless specified
-                temperature: options.temperature || 0.7,
+                ...(streamSampling.temperature !== undefined && {
+                    temperature: streamSampling.temperature,
+                }),
             },
         };
         if (toolConfig) {

package/dist/lib/providers/anthropic.js

@@ -25,7 +25,7 @@ import { buildNoOutputSentinel, stampNoOutputSpan, } from "../utils/noOutputSent
 import { convertZodToJsonSchema } from "../utils/schemaConversion.js";
 import { resolveClaudeMaxTokens } from "../utils/tokenLimits.js";
 import { toAnthropicImageBlock, fileToAnthropicBlock, } from "./anthropicImageBlocks.js";
-import { modelDeprecatesTemperature } from "../core/modules/structuredOutputPolicy.js";
+import { resolveSamplingParams } from "../models/modelRegistry.js";
 import { createChunkQueue, createDeferredAnalytics, stringifyToolInput, } from "./openaiChatCompletionsClient.js";
 /**
  * Beta headers for Claude Code integration.
@@ -1139,18 +1139,28 @@ export class AnthropicProvider extends BaseProvider {
                     messages: messages,
                 });
                 const cachedMessages = applyAnthropicHistoryCacheBreakpoints(messages, ANTHROPIC_MAX_CACHE_BREAKPOINTS - cacheMarkersUsed);
+                // Registry-driven strip: Sonnet 5 / Opus 4.7+ / Fable 5 families
+                // reject sampling params (also covers the retry paths — this params
+                // object is what any rebuild spreads).
+                const samplingParams = resolveSamplingParams("anthropic", modelId, {
+                    ...(options.temperature !== undefined &&
+                        options.temperature !== null
+                        ? { temperature: options.temperature }
+                        : {}),
+                    ...(options.topP !== undefined && options.topP !== null
+                        ? { topP: options.topP }
+                        : {}),
+                }, "anthropic.doGenerate");
                 const params = {
                     model: modelId,
                     messages: cachedMessages,
                     max_tokens: resolveClaudeMaxTokens(modelId, options.maxOutputTokens),
                     ...(system ? { system } : {}),
-                    ...(options.temperature !== undefined &&
-                        options.temperature !== null &&
-                        !modelDeprecatesTemperature(modelId)
-                        ? { temperature: options.temperature }
+                    ...(samplingParams.temperature !== undefined
+                        ? { temperature: samplingParams.temperature }
                         : {}),
-                    ...(options.topP !== undefined && options.topP !== null
-                        ? { top_p: options.topP }
+                    ...(samplingParams.topP !== undefined
+                        ? { top_p: samplingParams.topP }
                         : {}),
                     ...(options.stopSequences && options.stopSequences.length > 0
                         ? { stop_sequences: options.stopSequences }
@@ -1426,16 +1436,18 @@ export class AnthropicProvider extends BaseProvider {
                     messages: conversation,
                 });
                 const cachedConversation = applyAnthropicHistoryCacheBreakpoints(conversation, ANTHROPIC_MAX_CACHE_BREAKPOINTS - cacheMarkersUsed);
+                // Registry-driven strip (Sonnet 5 / Opus 4.7+ / Fable 5 families)
+                const streamSamplingParams = resolveSamplingParams("anthropic", modelId, options.temperature !== undefined && options.temperature !== null
+                    ? { temperature: options.temperature }
+                    : {}, "anthropic.executeStream");
                 const params = {
                     model: modelId,
                     messages: cachedConversation,
                     max_tokens: resolveClaudeMaxTokens(modelId, options.maxTokens),
                     stream: true,
                     ...(payload.system ? { system: payload.system } : {}),
-                    ...(options.temperature !== undefined &&
-                        options.temperature !== null &&
-                        !modelDeprecatesTemperature(modelId)
-                        ? { temperature: options.temperature }
+                    ...(streamSamplingParams.temperature !== undefined
+                        ? { temperature: streamSamplingParams.temperature }
                         : {}),
                     ...(anthropicTools && anthropicTools.length > 0
                         ? { tools: anthropicTools }