@flutchai/flutch-sdk 0.6.3 → 0.6.6

package/dist/index.cjs

@@ -1908,13 +1908,13 @@ async function findAvailablePort(startPort) {
   throw new Error(`No available ports found in range ${startPort}-${startPort + 99}`);
 }
 __name(findAvailablePort, "findAvailablePort");
-async function registerWithServiceDiscovery(AppModule, port, logger2, app) {
+async function registerWithServiceDiscovery(AppModule, port, logger3, app) {
   try {
-    logger2.debug("[SERVICE_DISCOVERY] Starting service discovery registration...");
+    logger3.debug("[SERVICE_DISCOVERY] Starting service discovery registration...");
     const { FileBasedDiscovery: FileBasedDiscovery2 } = await Promise.resolve().then(() => (init_file_based_discovery(), file_based_discovery_exports));
-    logger2.debug("[SERVICE_DISCOVERY] FileBasedDiscovery imported successfully");
+    logger3.debug("[SERVICE_DISCOVERY] FileBasedDiscovery imported successfully");
     const discovery = new FileBasedDiscovery2();
-    logger2.debug("[SERVICE_DISCOVERY] FileBasedDiscovery instance created");
+    logger3.debug("[SERVICE_DISCOVERY] FileBasedDiscovery instance created");
     const serviceName = AppModule.name.replace("Module", "").toLowerCase();
     let graphTypes = [];
     try {
@@ -1923,26 +1923,26 @@ async function registerWithServiceDiscovery(AppModule, port, logger2, app) {
         const builderRegistry = app.get(BuilderRegistryService2, {
           strict: false
         });
-        logger2.debug(`BuilderRegistryService found in DI: ${!!builderRegistry}`);
+        logger3.debug(`BuilderRegistryService found in DI: ${!!builderRegistry}`);
         if (builderRegistry) {
           const builders = builderRegistry.getBuilders();
-          logger2.debug(`Found ${builders.length} builders in registry`);
+          logger3.debug(`Found ${builders.length} builders in registry`);
           const baseGraphTypes = builders.map((builder) => builder.graphType);
-          logger2.debug(`Base graph types: [${baseGraphTypes.join(", ")}]`);
+          logger3.debug(`Base graph types: [${baseGraphTypes.join(", ")}]`);
           try {
-            logger2.debug("Attempting to import VersionedGraphService...");
+            logger3.debug("Attempting to import VersionedGraphService...");
             const { VersionedGraphService: VersionedGraphService2 } = await Promise.resolve().then(() => (init_versioned_graph_service(), versioned_graph_service_exports));
-            logger2.debug("VersionedGraphService imported successfully");
+            logger3.debug("VersionedGraphService imported successfully");
             const versionedService = app.get(VersionedGraphService2, {
               strict: false
             });
-            logger2.debug(`VersionedGraphService found in DI: ${!!versionedService}`);
+            logger3.debug(`VersionedGraphService found in DI: ${!!versionedService}`);
             if (versionedService) {
               const allVersionedTypes = [];
               for (const baseType of baseGraphTypes) {
-                logger2.debug(`Getting versions for base type: ${baseType}`);
+                logger3.debug(`Getting versions for base type: ${baseType}`);
                 const versions = versionedService.getAvailableVersions(baseType);
-                logger2.debug(`Found ${versions.length} versions for ${baseType}: [${versions.join(", ")}]`);
+                logger3.debug(`Found ${versions.length} versions for ${baseType}: [${versions.join(", ")}]`);
                 if (versions.length > 0) {
                   allVersionedTypes.push(baseType);
                   versions.forEach((version) => {
@@ -1953,23 +1953,23 @@ async function registerWithServiceDiscovery(AppModule, port, logger2, app) {
                 }
               }
               graphTypes = allVersionedTypes;
-              logger2.debug(`Found ${baseGraphTypes.length} base types with ${graphTypes.length} total versioned types: ${graphTypes.join(", ")}`);
+              logger3.debug(`Found ${baseGraphTypes.length} base types with ${graphTypes.length} total versioned types: ${graphTypes.join(", ")}`);
             } else {
               graphTypes = baseGraphTypes;
-              logger2.debug(`VersionedGraphService not found in DI container, using base types: ${graphTypes.join(", ")}`);
+              logger3.debug(`VersionedGraphService not found in DI container, using base types: ${graphTypes.join(", ")}`);
             }
           } catch (error) {
             graphTypes = baseGraphTypes;
-            logger2.debug(`Failed to get versioned types, using base types: ${error.message}`);
-            logger2.debug(`Stack trace: ${error.stack}`);
+            logger3.debug(`Failed to get versioned types, using base types: ${error.message}`);
+            logger3.debug(`Stack trace: ${error.stack}`);
           }
         }
       }
     } catch (error) {
-      logger2.debug(`Failed to get graph types from builders: ${error.message}`);
+      logger3.debug(`Failed to get graph types from builders: ${error.message}`);
     }
     if (graphTypes.length === 0) {
-      logger2.debug("No builders found, using service name as graph type");
+      logger3.debug("No builders found, using service name as graph type");
       graphTypes = [
         serviceName
       ];
@@ -1980,21 +1980,21 @@ async function registerWithServiceDiscovery(AppModule, port, logger2, app) {
       startTime: (/* @__PURE__ */ new Date()).toISOString(),
       version: process.env.npm_package_version || "1.0.0"
     }, graphTypes);
-    logger2.log(`\u{1F4E1} Service registered with discovery: ${serviceName} (types: ${graphTypes.join(", ")})`);
+    logger3.log(`\u{1F4E1} Service registered with discovery: ${serviceName} (types: ${graphTypes.join(", ")})`);
   } catch (error) {
-    logger2.warn(`Failed to register with service discovery: ${error.message}`);
+    logger3.warn(`Failed to register with service discovery: ${error.message}`);
   }
 }
 __name(registerWithServiceDiscovery, "registerWithServiceDiscovery");
 async function bootstrap(AppModule, options = {}) {
   setupRedisMock();
   const app = await core.NestFactory.create(AppModule);
-  const logger2 = new common.Logger("Bootstrap");
+  const logger3 = new common.Logger("Bootstrap");
   const requestedPort = options.port || parseInt(process.env.PORT || "3100", 10);
   const port = await findAvailablePort(requestedPort);
   const globalPrefix = options.globalPrefix;
   if (port !== requestedPort) {
-    logger2.warn(`Port ${requestedPort} is busy, using port ${port} instead`);
+    logger3.warn(`Port ${requestedPort} is busy, using port ${port} instead`);
   }
   if (globalPrefix) {
     app.setGlobalPrefix(globalPrefix);
@@ -2013,13 +2013,13 @@ async function bootstrap(AppModule, options = {}) {
   swagger.SwaggerModule.setup("api/docs", app, document);
   await app.listen(port);
   const baseUrl = globalPrefix ? `http://localhost:${port}/${globalPrefix}` : `http://localhost:${port}`;
-  logger2.log(`\u{1F680} Graph service is running on: ${baseUrl}`);
-  logger2.log(`\u{1F4DA} API Documentation: http://localhost:${port}/api/docs`);
+  logger3.log(`\u{1F680} Graph service is running on: ${baseUrl}`);
+  logger3.log(`\u{1F4DA} API Documentation: http://localhost:${port}/api/docs`);
   if (process.env.NODE_ENV !== "production") {
-    logger2.debug(`Attempting service discovery registration (NODE_ENV: ${process.env.NODE_ENV || "undefined"})`);
-    await registerWithServiceDiscovery(AppModule, port, logger2, app);
+    logger3.debug(`Attempting service discovery registration (NODE_ENV: ${process.env.NODE_ENV || "undefined"})`);
+    await registerWithServiceDiscovery(AppModule, port, logger3, app);
   } else {
-    logger2.debug(`Skipping service discovery registration (NODE_ENV: ${process.env.NODE_ENV})`);
+    logger3.debug(`Skipping service discovery registration (NODE_ENV: ${process.env.NODE_ENV})`);
   }
   return app;
 }
@@ -4872,7 +4872,7 @@ function clearAttachmentDataStore(threadId) {
 }
 __name(clearAttachmentDataStore, "clearAttachmentDataStore");
 async function executeToolWithAttachments(params) {
-  const { toolCall, mcpClient, enrichedArgs, executionContext, config, attachments, logger: logger2, threshold = DEFAULT_ATTACHMENT_THRESHOLD, injectIntoArg = "data", sourceAttachmentId, threadId, toolSchema, mcpServers } = params;
+  const { toolCall, mcpClient, enrichedArgs, executionContext, config, attachments, logger: logger3, threshold = DEFAULT_ATTACHMENT_THRESHOLD, injectIntoArg = "data", sourceAttachmentId, threadId, toolSchema, mcpServers } = params;
   const argsWithInjection = {
     ...enrichedArgs
   };
@@ -4885,12 +4885,12 @@ async function executeToolWithAttachments(params) {
         const data = storedData !== void 0 ? storedData : attachment.data;
         if (data != null) {
           argsWithInjection[injectIntoArg] = typeof data === "string" ? data : JSON.stringify(data);
-          logger2?.debug(`[Attachment] Auto-injected data from attachment "${attachment.toolCallId}" into ${toolCall.name}.${injectIntoArg} (source: ${storedData !== void 0 ? "memory" : "state"})`);
+          logger3?.debug(`[Attachment] Auto-injected data from attachment "${attachment.toolCallId}" into ${toolCall.name}.${injectIntoArg} (source: ${storedData !== void 0 ? "memory" : "state"})`);
         }
       }
     }
   } catch (e) {
-    logger2?.warn(`[Attachment] Auto-injection failed: ${e}`);
+    logger3?.warn(`[Attachment] Auto-injection failed: ${e}`);
   }
   const { content, success, rawResult } = await mcpClient.executeToolWithEvents(toolCall.id, toolCall.name, argsWithInjection, executionContext, config, mcpServers);
   try {
@@ -4901,7 +4901,7 @@ async function executeToolWithAttachments(params) {
         ...attachment,
         data: null
       };
-      logger2?.debug(`[Attachment] Stored large result (${content.length} chars) as attachment "${toolCall.id}" (data in memory, metadata in state)`);
+      logger3?.debug(`[Attachment] Stored large result (${content.length} chars) as attachment "${toolCall.id}" (data in memory, metadata in state)`);
       const toolMessage2 = new messages.ToolMessage({
         content: attachment.summary,
         tool_call_id: toolCall.id,
@@ -4916,7 +4916,7 @@ async function executeToolWithAttachments(params) {
       };
     }
   } catch (e) {
-    logger2?.warn(`[Attachment] Failed to create attachment, using full content: ${e}`);
+    logger3?.warn(`[Attachment] Failed to create attachment, using full content: ${e}`);
   }
   const toolMessage = new messages.ToolMessage({
     content,
@@ -6230,7 +6230,7 @@ function createMetaBuilder(config, versionedGraphService, moduleRef) {
 }
 __name(createMetaBuilder, "createMetaBuilder");
 function buildCheckpointerProviders(options) {
-  const logger2 = new common.Logger("UniversalGraphModule");
+  const logger3 = new common.Logger("UniversalGraphModule");
   if (options.postgres !== void 0) {
     return [
       {
@@ -6244,7 +6244,7 @@ function buildCheckpointerProviders(options) {
           if (!connString) {
             throw new Error("[UniversalGraphModule] Postgres checkpointer: provide postgres.connectionString or set the DATABASE_URL environment variable.");
           }
-          logger2.log(`Checkpointer: PostgreSQL (${connString.replace(/:[^:@]+@/, ":***@")})`);
+          logger3.log(`Checkpointer: PostgreSQL (${connString.replace(/:[^:@]+@/, ":***@")})`);
           const saver = PostgresSaver.fromConnString(connString, {
             ...options.postgres.schema ? {
               schema: options.postgres.schema
@@ -6266,7 +6266,7 @@ function buildCheckpointerProviders(options) {
           if (!mongoUri) {
             throw new Error("[UniversalGraphModule] MongoDB checkpointer: provide mongodb.uri or set the MONGODB_URI environment variable.");
           }
-          logger2.log(`Checkpointer: MongoDB (${mongoUri.substring(0, 50)}...)`);
+          logger3.log(`Checkpointer: MongoDB (${mongoUri.substring(0, 50)}...)`);
           await mongoose__default.default.connect(mongoUri, {
             dbName
           });
@@ -6300,7 +6300,7 @@ function buildCheckpointerProviders(options) {
       provide: "CHECKPOINTER",
       useFactory: /* @__PURE__ */ __name(async () => {
         const { MemorySaver } = await import('@langchain/langgraph');
-        logger2.warn("Checkpointer: MemorySaver (in-process, no persistence). Configure postgres or mongodb in UniversalGraphModule.forRoot() for production.");
+        logger3.warn("Checkpointer: MemorySaver (in-process, no persistence). Configure postgres or mongodb in UniversalGraphModule.forRoot() for production.");
         return new MemorySaver();
       }, "useFactory")
     }
@@ -6339,8 +6339,8 @@ exports.UniversalGraphModule = class _UniversalGraphModule {
           const redisUrl = options.redis?.url ?? process.env.REDIS_URL;
           if (redisUrl) {
             const Redis2 = __require("ioredis");
-            const logger2 = new common.Logger("UniversalGraphModule");
-            logger2.log(`Callbacks: Redis (${redisUrl.replace(/:[^:@]+@/, ":***@")})`);
+            const logger3 = new common.Logger("UniversalGraphModule");
+            logger3.log(`Callbacks: Redis (${redisUrl.replace(/:[^:@]+@/, ":***@")})`);
             return new Redis2(redisUrl);
           }
           const IORedisMock = __require("ioredis-mock");
@@ -6624,7 +6624,7 @@ var McpConverter = class _McpConverter {
   * Convert a single MCP tool to LangChain DynamicStructuredTool
   */
   convertTool(mcpTool) {
-    const logger2 = this.logger;
+    const logger3 = this.logger;
     const mcpRuntimeUrl = this.mcpRuntimeUrl;
     let enhancedDescription = mcpTool.description;
     if (mcpTool.inputSchema?.properties) {
@@ -6644,12 +6644,12 @@ ${paramDescriptions.join("\n")}`;
       }
     }
     const schema = this.jsonSchemaToZod(mcpTool.inputSchema);
-    logger2.debug(`\u{1F527} [${mcpTool.name}] Original schema:`, JSON.stringify(mcpTool.inputSchema, null, 2));
-    logger2.debug(`\u{1F527} [${mcpTool.name}] Using schema type: ${schema?._def?.typeName ?? "unknown"}`);
+    logger3.debug(`\u{1F527} [${mcpTool.name}] Original schema:`, JSON.stringify(mcpTool.inputSchema, null, 2));
+    logger3.debug(`\u{1F527} [${mcpTool.name}] Using schema type: ${schema?._def?.typeName ?? "unknown"}`);
     if (schema?._def?.shape && typeof schema._def.shape === "function") {
       try {
         const shape = schema._def.shape();
-        logger2.debug(`\u{1F527} [${mcpTool.name}] Converted Zod schema shape:`, JSON.stringify(Object.entries(shape).reduce((acc, [key, val]) => {
+        logger3.debug(`\u{1F527} [${mcpTool.name}] Converted Zod schema shape:`, JSON.stringify(Object.entries(shape).reduce((acc, [key, val]) => {
           acc[key] = {
             type: val?._def?.typeName,
             description: val?._def?.description,
@@ -6658,50 +6658,50 @@ ${paramDescriptions.join("\n")}`;
           return acc;
         }, {}), null, 2));
       } catch (error) {
-        logger2.debug(`\u{1F527} [${mcpTool.name}] Could not extract Zod schema shape: ${error}`);
+        logger3.debug(`\u{1F527} [${mcpTool.name}] Could not extract Zod schema shape: ${error}`);
       }
     }
     try {
       const convertedJsonSchema = zodToJsonSchema.zodToJsonSchema(schema);
-      logger2.warn(`\u{1F527} [${mcpTool.name}] JSON Schema that LangChain will use:`, JSON.stringify(convertedJsonSchema, null, 2));
+      logger3.warn(`\u{1F527} [${mcpTool.name}] JSON Schema that LangChain will use:`, JSON.stringify(convertedJsonSchema, null, 2));
     } catch (error) {
-      logger2.warn(`\u{1F527} [${mcpTool.name}] Could not convert Zod to JSON Schema: ${error}`);
+      logger3.warn(`\u{1F527} [${mcpTool.name}] Could not convert Zod to JSON Schema: ${error}`);
     }
     return new tools.DynamicStructuredTool({
       name: mcpTool.name,
       description: enhancedDescription,
       schema,
       func: /* @__PURE__ */ __name(async (input, _runManager, config) => {
-        logger2.log(`\u{1F527} [${mcpTool.name}] LLM INPUT: ${JSON.stringify(input)}`);
+        logger3.log(`\u{1F527} [${mcpTool.name}] LLM INPUT: ${JSON.stringify(input)}`);
         const configurable = config?.configurable;
         const context = {
           agentId: configurable?.agentId,
           userId: configurable?.userId,
           threadId: configurable?.thread_id
         };
-        logger2.debug(`\u{1F527} [${mcpTool.name}] Execution context: ${JSON.stringify(context)}`);
+        logger3.debug(`\u{1F527} [${mcpTool.name}] Execution context: ${JSON.stringify(context)}`);
         try {
           const request = {
             name: mcpTool.name,
             arguments: input ?? {},
             context
           };
-          logger2.log(`\u{1F527} [${mcpTool.name}] Calling MCP Runtime...`);
+          logger3.log(`\u{1F527} [${mcpTool.name}] Calling MCP Runtime...`);
           const response = await axios2__default.default.post(`${mcpRuntimeUrl}/tools/execute`, request, {
             timeout: 3e4
           });
           const result = response.data;
-          logger2.log(`\u{1F527} [${mcpTool.name}] MCP Runtime response: success=${result.success}`);
+          logger3.log(`\u{1F527} [${mcpTool.name}] MCP Runtime response: success=${result.success}`);
           if (!result.success) {
             const errorMessage = result.error || "Tool execution failed";
-            logger2.error(`\u{1F527} [${mcpTool.name}] MCP Runtime error: ${errorMessage}`);
+            logger3.error(`\u{1F527} [${mcpTool.name}] MCP Runtime error: ${errorMessage}`);
             throw new Error(errorMessage);
           }
           const output = typeof result.result === "string" ? result.result : JSON.stringify(result.result, null, 2);
-          logger2.log(`\u{1F527} [${mcpTool.name}] TOOL OUTPUT: ${output.length > 200 ? output.substring(0, 200) + "..." : output}`);
+          logger3.log(`\u{1F527} [${mcpTool.name}] TOOL OUTPUT: ${output.length > 200 ? output.substring(0, 200) + "..." : output}`);
           return output;
         } catch (error) {
-          logger2.error(`\u{1F527} [${mcpTool.name}] Exception during execution`, error);
+          logger3.error(`\u{1F527} [${mcpTool.name}] Exception during execution`, error);
           if (axios2__default.default.isAxiosError(error)) {
             throw new Error(`MCP Runtime error: ${error.message}`);
           }
@@ -7076,6 +7076,110 @@ function isReasoningModel(modelName) {
   return modelName.includes("gpt-5") || modelName.includes("gpt-o1") || modelName.includes("gpt-o2") || modelName.includes("gpt-o3") || modelName.includes("gpt-o4") || /^gpt-(5|6|7|8|9)/.test(modelName) || /^gpt-o[1-4]/.test(modelName);
 }
 __name(isReasoningModel, "isReasoningModel");
+function toOptionalNumber(value) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  const n = Number(value);
+  return Number.isFinite(n) ? n : void 0;
+}
+__name(toOptionalNumber, "toOptionalNumber");
+var SAMPLING_PARAM_FREE_THRESHOLDS = {
+  opus: {
+    major: 4,
+    minor: 7
+  },
+  sonnet: {
+    major: 5,
+    minor: 0
+  },
+  haiku: {
+    major: 5,
+    minor: 0
+  }
+};
+var SAMPLING_PARAM_FREE_FAMILIES = /claude-(fable|mythos)\b/;
+var CLAUDE_FAMILY_VERSION = /claude-(opus|sonnet|haiku)-(\d{1,2})(?:-(\d{1,2}))?(?![\d.])/;
+function modelAcceptsSamplingParams(modelIdentifier) {
+  if (!modelIdentifier) return true;
+  const id = modelIdentifier.toLowerCase();
+  if (SAMPLING_PARAM_FREE_FAMILIES.test(id)) return false;
+  const match = CLAUDE_FAMILY_VERSION.exec(id);
+  if (!match) return true;
+  const [, family, majorRaw, minorRaw] = match;
+  const threshold = SAMPLING_PARAM_FREE_THRESHOLDS[family];
+  if (!threshold) return true;
+  const major = Number(majorRaw);
+  const minor = minorRaw === void 0 ? 0 : Number(minorRaw);
+  const atOrAboveThreshold = major > threshold.major || major === threshold.major && minor >= threshold.minor;
+  return !atOrAboveThreshold;
+}
+__name(modelAcceptsSamplingParams, "modelAcceptsSamplingParams");
+var PROMPT_CACHE_MIN_VERSIONS = {
+  opus: {
+    major: 4,
+    minor: 0
+  },
+  sonnet: {
+    major: 4,
+    minor: 0
+  },
+  haiku: {
+    major: 4,
+    minor: 5
+  }
+};
+function modelSupportsPromptCache(modelIdentifier) {
+  if (!modelIdentifier) return false;
+  const match = CLAUDE_FAMILY_VERSION.exec(modelIdentifier.toLowerCase());
+  if (!match) return false;
+  const [, family, majorRaw, minorRaw] = match;
+  const threshold = PROMPT_CACHE_MIN_VERSIONS[family];
+  if (!threshold) return false;
+  const major = Number(majorRaw);
+  const minor = minorRaw === void 0 ? 0 : Number(minorRaw);
+  return major > threshold.major || major === threshold.major && minor >= threshold.minor;
+}
+__name(modelSupportsPromptCache, "modelSupportsPromptCache");
+function resolvePromptCacheControl(modelIdentifiers, promptCache, ttl) {
+  const enabled = promptCache ?? modelIdentifiers.some((id) => modelSupportsPromptCache(id));
+  return enabled ? {
+    type: "ephemeral",
+    ttl: ttl ?? "5m"
+  } : void 0;
+}
+__name(resolvePromptCacheControl, "resolvePromptCacheControl");
+function buildEffortRequestFields(effort) {
+  return effort ? {
+    output_config: {
+      effort
+    }
+  } : void 0;
+}
+__name(buildEffortRequestFields, "buildEffortRequestFields");
+function resolveSamplingParams(modelIdentifiers, requested, supportsSamplingParams) {
+  const accepted = supportsSamplingParams ?? modelIdentifiers.every((id) => modelAcceptsSamplingParams(id));
+  if (accepted) {
+    const params = {};
+    if (requested.temperature !== void 0) params.temperature = requested.temperature;
+    if (requested.topP !== void 0) params.topP = requested.topP;
+    if (requested.topK !== void 0) params.topK = requested.topK;
+    return {
+      params,
+      dropped: [],
+      accepted: true
+    };
+  }
+  const dropped = [
+    "temperature",
+    "topP",
+    "topK"
+  ].filter((key) => requested[key] !== void 0);
+  return {
+    params: {},
+    dropped,
+    accepted: false
+  };
+}
+__name(resolveSamplingParams, "resolveSamplingParams");
 function hashToolsConfig(toolsConfig) {
   const sorted = toolsConfig.map((t) => `${t.toolName}:${t.enabled}:${JSON.stringify(t.config || {})}`).sort().join("|");
   return crypto.createHash("md5").update(sorted).digest("hex").slice(0, 16);
@@ -7128,13 +7232,122 @@ function buildOpenAIModelConfig(modelName, temperature, maxTokens, apiToken) {
   }
   return {
     modelName,
-    temperature,
+    // Omit the key entirely when absent — an explicit `undefined` would still
+    // be enumerable and can be forwarded as a null-ish value downstream.
+    ...temperature !== void 0 && {
+      temperature
+    },
     maxTokens,
     streaming: true,
     openAIApiKey: apiToken
   };
 }
 __name(buildOpenAIModelConfig, "buildOpenAIModelConfig");
+
+// src/models/reasoning-content.logic.ts
+function isReasoningBlock(block) {
+  return typeof block === "object" && block !== null && block.type === "reasoning_content";
+}
+__name(isReasoningBlock, "isReasoningBlock");
+function isSendableReasoningBlock(block) {
+  if (typeof block.redactedContent === "string" && block.redactedContent !== "") return true;
+  const text = block.reasoningText?.text;
+  return typeof text === "string" && text !== "";
+}
+__name(isSendableReasoningBlock, "isSendableReasoningBlock");
+function normalizeUnsendableBlock(block) {
+  const signature = block.reasoningText?.signature;
+  if (typeof signature !== "string" || signature === "") return null;
+  return {
+    type: "reasoning_content",
+    reasoningText: {
+      text: "",
+      signature
+    }
+  };
+}
+__name(normalizeUnsendableBlock, "normalizeUnsendableBlock");
+function hasToolCalls(message) {
+  const toolCalls = message.tool_calls;
+  return Array.isArray(toolCalls) && toolCalls.length > 0;
+}
+__name(hasToolCalls, "hasToolCalls");
+function withContent(message, content) {
+  const clone = Object.assign(Object.create(Object.getPrototypeOf(message)), message, {
+    content
+  });
+  if (clone.lc_kwargs) clone.lc_kwargs = {
+    ...clone.lc_kwargs,
+    content
+  };
+  return clone;
+}
+__name(withContent, "withContent");
+function sanitizeMessageReasoning(message) {
+  if (message.getType() !== "ai") return message;
+  const content = message.content;
+  if (!Array.isArray(content)) return message;
+  const unsendable = content.filter((block) => isReasoningBlock(block) && !isSendableReasoningBlock(block));
+  if (unsendable.length === 0) return message;
+  const kept = content.filter((block) => !unsendable.includes(block));
+  if (kept.length === 0 && !hasToolCalls(message)) {
+    for (let i = unsendable.length - 1; i >= 0; i--) {
+      const normalized = normalizeUnsendableBlock(unsendable[i]);
+      if (normalized) return withContent(message, [
+        normalized
+      ]);
+    }
+  }
+  return withContent(message, kept);
+}
+__name(sanitizeMessageReasoning, "sanitizeMessageReasoning");
+function sanitizeReasoningForBedrock(messages) {
+  let sanitized = 0;
+  let next;
+  for (let i = 0; i < messages.length; i++) {
+    const cleaned = sanitizeMessageReasoning(messages[i]);
+    if (cleaned === messages[i]) continue;
+    if (!next) next = [
+      ...messages
+    ];
+    next[i] = cleaned;
+    const before = messages[i].content.length;
+    const after = cleaned.content.length;
+    sanitized += Math.max(1, before - after);
+  }
+  return {
+    messages: next ?? messages,
+    sanitized
+  };
+}
+__name(sanitizeReasoningForBedrock, "sanitizeReasoningForBedrock");
+
+// src/models/bedrock-chat-model.ts
+var logger2 = new common.Logger("FlutchChatBedrockConverse");
+var FlutchChatBedrockConverse = class extends aws.ChatBedrockConverse {
+  static {
+    __name(this, "FlutchChatBedrockConverse");
+  }
+  static lc_name() {
+    return "FlutchChatBedrockConverse";
+  }
+  sanitize(messages) {
+    const { messages: cleaned, sanitized } = sanitizeReasoningForBedrock(messages);
+    if (sanitized > 0) {
+      logger2.debug(`Dropped ${sanitized} unsendable reasoning block(s) from outgoing history (model=${this.model})`);
+    }
+    return cleaned;
+  }
+  /** `.invoke()` / `.generate()` path. */
+  async _generate(messages, options, runManager) {
+    return super._generate(this.sanitize(messages), options, runManager);
+  }
+  /** `.stream()` / `streamEvents()` path (also used by `_generate` when the
+  * model is constructed with `streaming: true` — sanitizing is idempotent). */
+  async *_streamResponseChunks(messages, options, runManager) {
+    yield* super._streamResponseChunks(this.sanitize(messages), options, runManager);
+  }
+};
 var VoyageAIRerank = class extends document_compressors.BaseDocumentCompressor {
   static {
     __name(this, "VoyageAIRerank");
@@ -7206,10 +7419,10 @@ var ModelInitializer = class _ModelInitializer {
     [ModelProvider.COHERE]: "COHERE_API_KEY",
     [ModelProvider.VOYAGEAI]: "VOYAGEAI_API_KEY"
   };
-  constructor(configFetcher, logger2, apiKeyResolver) {
+  constructor(configFetcher, logger3, apiKeyResolver) {
     this.configFetcher = configFetcher;
     this.apiKeyResolver = apiKeyResolver;
-    this.logger = logger2 || new common.Logger(_ModelInitializer.name);
+    this.logger = logger3 || new common.Logger(_ModelInitializer.name);
   }
   /**
   * Resolve API key for a provider.
@@ -7232,6 +7445,32 @@ var ModelInitializer = class _ModelInitializer {
     return process.env.BEDROCK_AWS_REGION || process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION || "us-east-1";
   }
   /**
+  * Resolve sampling parameters for a model, dropping them when the model
+  * does not accept them (Claude Opus 4.7+, Claude 5 and newer).
+  *
+  * An explicitly requested value on such a model is **ignored with a warning**
+  * rather than raising: the request must keep working, and the model runs at
+  * its own default sampling behaviour. Pass `supportsSamplingParams: true` in
+  * the config to force the params through anyway.
+  *
+  * @param modelIdentifiers every name the model is known by (catalog model
+  *   name, Bedrock model id, …) — a match on any of them drops the params
+  * @param wasExplicit whether the caller explicitly asked for these values
+  *   (as opposed to inheriting a catalog/SDK default) — controls log level
+  */
+  resolveSampling(modelIdentifiers, requested, supportsSamplingParams, wasExplicit = false) {
+    const resolved = resolveSamplingParams(modelIdentifiers, requested, supportsSamplingParams);
+    if (!resolved.accepted && resolved.dropped.length > 0) {
+      const message = `Model ${modelIdentifiers.filter(Boolean).join(" / ")} does not accept sampling parameters \u2014 ignoring ${resolved.dropped.join(", ")}. Set supportsSamplingParams: true to override.`;
+      if (wasExplicit) {
+        this.logger.warn(message);
+      } else {
+        this.logger.debug(message);
+      }
+    }
+    return resolved.params;
+  }
+  /**
   * Generate hash from toolsConfig for cache key
   * Uses MD5 hash to create short, unique identifier
   */
@@ -7245,10 +7484,10 @@ var ModelInitializer = class _ModelInitializer {
   */
   generateModelCacheKey(config) {
     const base = generateModelCacheKey(config.modelId, config.temperature, config.maxTokens, config.toolsConfig, config.baseURL);
-    if (config.mcpServers && config.mcpServers.length > 0) {
-      return `${base}:mcp:${JSON.stringify(config.mcpServers)}`;
-    }
-    return base;
+    const withMcp = config.mcpServers && config.mcpServers.length > 0 ? `${base}:mcp:${JSON.stringify(config.mcpServers)}` : base;
+    const withSampling = config.supportsSamplingParams === void 0 ? withMcp : `${withMcp}:sp:${config.supportsSamplingParams}`;
+    const withCache = config.promptCache === void 0 && config.promptCacheTtl === void 0 ? withSampling : `${withSampling}:pc:${config.promptCache ?? "auto"}:${config.promptCacheTtl ?? "default"}`;
+    return config.effort === void 0 ? withCache : `${withCache}:eff:${config.effort}`;
   }
   // Chat model creators
   chatModelCreators = {
@@ -7263,12 +7502,23 @@ var ModelInitializer = class _ModelInitializer {
       }
       return new openai.ChatOpenAI(config);
     },
-    [ModelProvider.ANTHROPIC]: ({ modelName, defaultTemperature, defaultMaxTokens, apiToken, baseURL }) => {
+    [ModelProvider.ANTHROPIC]: ({ modelName, defaultTemperature, defaultMaxTokens, apiToken, baseURL }, promptCacheControl) => {
       const routerURL = resolveRouterURL(baseURL);
       return new anthropic.ChatAnthropic({
         modelName,
-        temperature: defaultTemperature,
+        // Claude Opus 4.7+ / Claude 5 reject `temperature` outright — the key
+        // must be absent, not `undefined`.
+        ...defaultTemperature !== void 0 && {
+          temperature: defaultTemperature
+        },
         maxTokens: defaultMaxTokens,
+        // Top-level prompt caching: one breakpoint on the last cacheable block,
+        // advanced automatically as the conversation grows. Survives the router
+        // (which forwards the Anthropic body untouched) and is accepted by
+        // Bedrock's InvokeModel schema behind it.
+        ...promptCacheControl && {
+          cache_control: promptCacheControl
+        },
         anthropicApiKey: apiToken || this.resolveApiKey(ModelProvider.ANTHROPIC),
         ...routerURL && {
           anthropicApiUrl: routerURL,
@@ -7283,7 +7533,9 @@ var ModelInitializer = class _ModelInitializer {
       const token = apiToken || this.resolveApiKey(ModelProvider.COHERE);
       return routerURL ? new cohere.ChatCohere({
         model: modelName,
-        temperature: defaultTemperature,
+        ...defaultTemperature !== void 0 && {
+          temperature: defaultTemperature
+        },
         client: new cohereAi.CohereClient({
           token,
           baseUrl: routerURL,
@@ -7293,7 +7545,9 @@ var ModelInitializer = class _ModelInitializer {
         })
       }) : new cohere.ChatCohere({
         model: modelName,
-        temperature: defaultTemperature,
+        ...defaultTemperature !== void 0 && {
+          temperature: defaultTemperature
+        },
         apiKey: token
       });
     },
@@ -7301,7 +7555,9 @@ var ModelInitializer = class _ModelInitializer {
       const routerURL = resolveRouterURL(baseURL);
       return new mistralai.ChatMistralAI({
         model: modelName,
-        temperature: defaultTemperature,
+        ...defaultTemperature !== void 0 && {
+          temperature: defaultTemperature
+        },
         maxTokens: defaultMaxTokens,
         apiKey: apiToken || this.resolveApiKey(ModelProvider.MISTRAL),
         ...routerURL && {
@@ -7391,7 +7647,8 @@ var ModelInitializer = class _ModelInitializer {
   async initializeChatModelDirect(config, customTools) {
     const toolsConfig = normalizeToolConfigs(config.tools);
     const modelIdentifier = `${config.provider}:${config.modelName}`;
-    const cacheKey = generateModelCacheKey(modelIdentifier, config.temperature, config.maxTokens, toolsConfig, config.baseURL);
+    const baseCacheKey = generateModelCacheKey(modelIdentifier, config.temperature, config.maxTokens, toolsConfig, config.baseURL);
+    const cacheKey = config.supportsSamplingParams === void 0 ? baseCacheKey : `${baseCacheKey}:sp:${config.supportsSamplingParams}`;
     const cached = this.modelInstanceCache.get(cacheKey);
     if (cached) {
       this.logger.debug(`Using cached chat model instance: ${cacheKey}`);
@@ -7402,18 +7659,23 @@ var ModelInitializer = class _ModelInitializer {
       throw new Error(`Unknown provider "${provider}". Valid: ${Object.values(ModelProvider).join(", ")}`);
     }
     const apiToken = this.resolveApiKey(provider);
-    const temperature = config.temperature ?? 0.7;
-    const maxTokens = config.maxTokens ?? 4096;
+    const maxTokens = toOptionalNumber(config.maxTokens) ?? 4096;
+    const sampling = this.resolveSampling([
+      config.modelName
+    ], {
+      temperature: toOptionalNumber(config.temperature) ?? 0.7
+    }, config.supportsSamplingParams, config.temperature !== void 0);
     const modelConfig = {
       modelId: modelIdentifier,
       modelName: config.modelName,
       provider,
       modelType: ModelType.CHAT,
-      defaultTemperature: Number(temperature),
-      defaultMaxTokens: Number(maxTokens),
+      defaultTemperature: sampling.temperature,
+      defaultMaxTokens: maxTokens,
       apiToken,
       requiresApiKey: true,
-      baseURL: config.baseURL
+      baseURL: config.baseURL,
+      supportsSamplingParams: config.supportsSamplingParams
     };
     this.logger.debug(`Creating chat model: ${modelIdentifier} (apiKeyResolved=${!!apiToken})`);
     const creator = this.chatModelCreators[provider];
@@ -7448,19 +7710,40 @@ var ModelInitializer = class _ModelInitializer {
     if (modelConfig.modelType !== ModelType.CHAT) {
       throw new Error(`Model ${config.modelId} is not a chat model (type: ${modelConfig.modelType})`);
     }
+    const requestedTemperature = toOptionalNumber(config.temperature) ?? toOptionalNumber(modelConfig.defaultTemperature);
+    const sampling = this.resolveSampling([
+      modelConfig.modelName,
+      modelConfig.bedrockModelId
+    ], {
+      temperature: requestedTemperature
+    }, config.supportsSamplingParams ?? modelConfig.supportsSamplingParams, config.temperature !== void 0);
     const finalConfig = {
       ...modelConfig,
-      defaultTemperature: Number(config.temperature ?? modelConfig.defaultTemperature),
-      defaultMaxTokens: Number(config.maxTokens ?? modelConfig.defaultMaxTokens),
+      defaultTemperature: sampling.temperature,
+      defaultMaxTokens: toOptionalNumber(config.maxTokens) ?? toOptionalNumber(modelConfig.defaultMaxTokens),
       baseURL: config.baseURL ?? modelConfig.baseURL
     };
+    const promptCacheControl = resolvePromptCacheControl([
+      finalConfig.bedrockModelId,
+      finalConfig.modelName
+    ], config.promptCache ?? modelConfig.promptCache, config.promptCacheTtl ?? modelConfig.promptCacheTtl);
+    if (promptCacheControl) {
+      this.logger.debug(`Prompt caching enabled for ${finalConfig.bedrockModelId ?? finalConfig.modelName} (ttl=${promptCacheControl.ttl})`);
+    }
     this.logger.debug(`Creating new chat model instance: ${cacheKey}`);
     let model;
     if (finalConfig.useBedrock && finalConfig.bedrockModelId) {
-      model = new aws.ChatBedrockConverse({
+      const effortFields = buildEffortRequestFields(config.effort ?? modelConfig.defaultEffort);
+      model = new FlutchChatBedrockConverse({
         model: finalConfig.bedrockModelId,
         region: this.resolveBedrockRegion(),
-        temperature: finalConfig.defaultTemperature,
+        // Key omitted (not `undefined`) for models that reject sampling params.
+        ...finalConfig.defaultTemperature !== void 0 && {
+          temperature: finalConfig.defaultTemperature
+        },
+        ...effortFields && {
+          additionalModelRequestFields: effortFields
+        },
         maxTokens: finalConfig.defaultMaxTokens,
         streaming: true
       });
@@ -7469,14 +7752,24 @@ var ModelInitializer = class _ModelInitializer {
       if (!creator) {
         throw new Error(`Chat models not supported for provider: ${modelConfig.provider}`);
       }
-      model = creator(finalConfig);
+      model = creator(finalConfig, promptCacheControl);
     }
     model.metadata = {
       ...model.metadata,
       modelId: config.modelId
     };
     if (config.toolsConfig || config.customTools || config.mcpServers && config.mcpServers.length > 0) {
-      const boundModel = await this.bindToolsToModel(model, config.toolsConfig, config.customTools, config.mcpServers, config.mcpContext);
+      const boundModel = await this.bindToolsToModel(
+        model,
+        config.toolsConfig,
+        config.customTools,
+        config.mcpServers,
+        config.mcpContext,
+        // Converse takes cache control as a per-call option; the Anthropic
+        // client already got it as a constructor field, and handing it the
+        // same value twice would put an unknown key in its call options.
+        finalConfig.useBedrock ? promptCacheControl : void 0
+      );
       this.modelInstanceCache.set(cacheKey, boundModel);
       return boundModel;
     }
@@ -7488,11 +7781,20 @@ var ModelInitializer = class _ModelInitializer {
   * For toolsConfig: fetch tool executors from MCP Runtime
   * For customTools: use as-is (already prepared DynamicStructuredTool)
   *
+  * `promptCacheControl` is the **Bedrock-only** half of prompt caching: it is
+  * bound alongside the tools as a default call option, and `ChatBedrockConverse`
+  * turns it into `cachePoint` blocks after the tool schemas, the system prompt
+  * and the last message. Tool schemas dominate the request, so this is the one
+  * place worth caching — a model with no tools keeps its plain `BaseChatModel`
+  * type and no cache points (callers there rely on `withStructuredOutput` and
+  * friends). The Anthropic client takes its cache settings in the constructor
+  * instead and must not be handed them again here.
+  *
   * Returns:
   * - Runnable when tools are bound (model.bindTools returns Runnable)
   * - BaseChatModel when no tools
   */
-  async bindToolsToModel(model, toolsConfig, customTools, mcpServers, mcpContext) {
+  async bindToolsToModel(model, toolsConfig, customTools, mcpServers, mcpContext, promptCacheControl) {
     const allTools = [];
     const enabledToolsConfig = (toolsConfig || []).filter((tc) => tc.enabled !== false);
     const hasInlineServers = !!(mcpServers && mcpServers.length > 0);
@@ -7513,7 +7815,10 @@ var ModelInitializer = class _ModelInitializer {
     }
     if (allTools.length > 0) {
       this.logger.debug(`Binding ${allTools.length} tools to model`);
-      const modelWithTools = model.bindTools(allTools);
+      const boundOptions = {
+        cache_control: promptCacheControl
+      };
+      const modelWithTools = promptCacheControl ? model.bindTools(allTools, boundOptions) : model.bindTools(allTools);
       return modelWithTools;
     }
     return model;
@@ -8319,6 +8624,7 @@ exports.DEFAULT_ROUTER_URL = DEFAULT_ROUTER_URL;
 exports.DEFAULT_TRACER_OPTIONS = DEFAULT_TRACER_OPTIONS;
 exports.Endpoint = Endpoint;
 exports.FileTokenStore = FileTokenStore;
+exports.FlutchChatBedrockConverse = FlutchChatBedrockConverse;
 exports.GraphEngineType = GraphEngineType;
 exports.GraphManifestSchema = GraphManifestSchema;
 exports.GraphManifestValidator = GraphManifestValidator;
@@ -8331,7 +8637,9 @@ exports.ModelProvider = ModelProvider;
 exports.ModelType = ModelType;
 exports.MongoTokenStore = MongoTokenStore;
 exports.OAuthTokenManager = OAuthTokenManager;
+exports.PROMPT_CACHE_MIN_VERSIONS = PROMPT_CACHE_MIN_VERSIONS;
 exports.RetrieverSearchType = RetrieverSearchType;
+exports.SAMPLING_PARAM_FREE_THRESHOLDS = SAMPLING_PARAM_FREE_THRESHOLDS;
 exports.StreamChannel = StreamChannel;
 exports.UIEndpoint = UIEndpoint;
 exports.UniversalCallbackService = UniversalCallbackService;
@@ -8341,6 +8649,7 @@ exports.WithEndpoints = WithEndpoints;
 exports.WithUIEndpoints = WithUIEndpoints;
 exports._internals = _internals;
 exports.bootstrap = bootstrap;
+exports.buildEffortRequestFields = buildEffortRequestFields;
 exports.buildOAuthAuthorizationUrl = buildOAuthAuthorizationUrl;
 exports.buildOpenAIModelConfig = buildOpenAIModelConfig;
 exports.clearAttachmentDataStore = clearAttachmentDataStore;
@@ -8371,15 +8680,24 @@ exports.hasCallbacks = hasCallbacks;
 exports.hasUIEndpoints = hasUIEndpoints;
 exports.hashToolsConfig = hashToolsConfig;
 exports.isInternalMode = isInternalMode;
+exports.isReasoningBlock = isReasoningBlock;
 exports.isReasoningModel = isReasoningModel;
+exports.isSendableReasoningBlock = isSendableReasoningBlock;
 exports.loadOAuthProviders = loadOAuthProviders;
+exports.modelAcceptsSamplingParams = modelAcceptsSamplingParams;
+exports.modelSupportsPromptCache = modelSupportsPromptCache;
 exports.normalizeToolConfigs = normalizeToolConfigs;
 exports.registerFinanceExampleCallback = registerFinanceExampleCallback;
 exports.registerUIEndpointsFromClass = registerUIEndpointsFromClass;
 exports.resolveOAuthProviderConfig = resolveOAuthProviderConfig;
+exports.resolvePromptCacheControl = resolvePromptCacheControl;
 exports.resolveRouterURL = resolveRouterURL;
+exports.resolveSamplingParams = resolveSamplingParams;
+exports.sanitizeMessageReasoning = sanitizeMessageReasoning;
+exports.sanitizeReasoningForBedrock = sanitizeReasoningForBedrock;
 exports.sanitizeTraceData = sanitizeTraceData;
 exports.storeAttachmentData = storeAttachmentData;
+exports.toOptionalNumber = toOptionalNumber;
 exports.traceApiCall = traceApiCall;
 exports.withFlutchContext = withFlutchContext;
 exports.wrapCohereFetcher = wrapCohereFetcher;