@librechat/agents 3.7.19 → 3.7.20

package/src/llm/openai/index.ts

@@ -122,6 +122,7 @@ type OpenAIClientConfig = NonNullable<
 >;
 type LibreChatOpenAIFields = t.ChatOpenAIFields & {
   _lc_stream_delay?: number;
+  firstPartyEndpoint?: boolean;
   includeReasoningContent?: boolean;
   includeReasoningDetails?: boolean;
   convertReasoningDetailsToContent?: boolean;
@@ -133,6 +134,7 @@ type LibreChatOpenAIFields = t.ChatOpenAIFields & {
 };
 type LibreChatAzureOpenAIFields = t.AzureOpenAIInput & {
   _lc_stream_delay?: number;
+  firstPartyEndpoint?: boolean;
   promptCacheExplicit?: boolean;
   safety_identifier?: string;
 };
@@ -503,13 +505,127 @@ export function addResponseCacheBreakpoints(
   );
 }
 
+/**
+ * GPT-6 Astra, matched on the model id rather than a `gpt-6` family cutoff.
+ *
+ * OpenAI documents these constraints for Astra specifically, and every gate
+ * keyed off this helper *removes* capability — it forces the Responses API,
+ * drops sampling parameters, and lowers reasoning effort. A false positive
+ * therefore silently degrades a sibling model that never needed it, so the
+ * match stays narrow until OpenAI documents the same rules more widely.
+ *
+ * Deliberately does NOT match a `provider/` prefixed id such as
+ * `openai/gpt-6-astra`. A slash means a proxy is doing the routing, and the
+ * proxy's contract is not OpenAI's: `ChatOpenRouter` extends this class, and on
+ * OpenRouter `effort: 'none'` is a *supported* value meaning "disable
+ * reasoning" (it maps to `include_reasoning: false`). Substituting it with
+ * `low` there would silently turn reasoning off into reasoning on, and forcing
+ * the Responses API would change the endpoint shape a proxy may not serve. Bare
+ * ids reach the first-party OpenAI and Azure surfaces these rules describe.
+ * @see https://developers.openai.com/api/docs/models/gpt-6-astra
+ * @see https://developers.openai.com/api/docs/guides/latest-model
+ */
+const GPT_6_ASTRA_PATTERN = /^gpt-6-astra(?:-|$)/i;
+
+/** @internal */
+export function isGpt6AstraModel(model?: string): boolean {
+  return model != null && GPT_6_ASTRA_PATTERN.test(model.toLowerCase());
+}
+
+/**
+ * Reasoning efforts GPT-6 Astra does not accept, mapped to the level OpenAI
+ * recommends migrating to. `none` is rejected outright and `minimal` is not
+ * offered; the migration guide says to "start with `low` and compare results".
+ * Substituting keeps a stored agent configuration usable instead of failing
+ * the turn on a value the previous model accepted.
+ */
+const GPT_6_ASTRA_UNSUPPORTED_EFFORTS = new Set(['none', 'minimal']);
+const GPT_6_ASTRA_EFFORT_FALLBACK = 'low' as const;
+
+function substituteUnsupportedAstraEffort(
+  astraRulesApply: boolean,
+  reasoning: OpenAIClient.Reasoning | undefined
+): OpenAIClient.Reasoning | undefined {
+  const effort = reasoning?.effort;
+  if (
+    effort == null ||
+    !astraRulesApply ||
+    !GPT_6_ASTRA_UNSUPPORTED_EFFORTS.has(effort)
+  ) {
+    return reasoning;
+  }
+  return { ...reasoning, effort: GPT_6_ASTRA_EFFORT_FALLBACK };
+}
+
+/** Rejected inside the Responses `include` array. */
+const GPT_6_ASTRA_UNSUPPORTED_INCLUDE: OpenAIClient.Responses.ResponseIncludable =
+  'message.output_text.logprobs';
+
+/**
+ * The subset of a request GPT-6 Astra rejects, taken from the SDK's own request
+ * types so the stripping boundary keeps their constraints. Every member is
+ * optional so a key can be deleted from a request object whose concrete type
+ * marks it required.
+ */
+type AstraStrippableParams = Partial<
+  Pick<
+    OpenAIClient.Chat.Completions.ChatCompletionCreateParams,
+    'temperature' | 'top_p' | 'logprobs' | 'top_logprobs'
+  >
+> &
+  Partial<Pick<OpenAIClient.Responses.ResponseCreateParams, 'include'>>;
+
+/**
+ * Removes the sampling and logprob parameters GPT-6 Astra rejects.
+ *
+ * LangChain's request builders emit `temperature` and `top_p` from instance
+ * fields unconditionally, so leaving them unset upstream is not enough — they
+ * are stripped after `super.invocationParams`. `logprobs` is Chat Completions
+ * only; the Responses equivalent rides inside `include`.
+ */
+function stripUnsupportedAstraParams<T extends object>(
+  astraRulesApply: boolean,
+  params: T,
+  endpoint: 'completions' | 'responses'
+): T {
+  if (!astraRulesApply) {
+    return params;
+  }
+  const next = { ...params };
+  const record = next as AstraStrippableParams;
+  delete record.temperature;
+  delete record.top_p;
+  delete record.top_logprobs;
+  if (endpoint === 'completions') {
+    delete record.logprobs;
+    return next;
+  }
+  const include = record.include;
+  if (!Array.isArray(include)) {
+    return next;
+  }
+  const filtered = include.filter(
+    (entry) => entry !== GPT_6_ASTRA_UNSUPPORTED_INCLUDE
+  );
+  if (filtered.length === include.length) {
+    return next;
+  }
+  if (filtered.length === 0) {
+    delete record.include;
+  } else {
+    record.include = filtered;
+  }
+  return next;
+}
+
 /** @internal */
 export function shouldIncludeEncryptedReasoning(
   model: string,
   params: {
     store?: boolean | null;
     reasoning?: unknown;
-  }
+  },
+  astraRulesApply = false
 ): boolean {
   const reasoningContext = (
     params.reasoning as
@@ -517,7 +633,7 @@ export function shouldIncludeEncryptedReasoning(
       | undefined
   )?.context;
   return (
-    /^gpt-5\.6(?:-|$)/i.test(model) &&
+    (/^gpt-5\.6(?:-|$)/i.test(model) || astraRulesApply) &&
     (params.store === false || reasoningContext !== 'current_turn')
   );
 }
@@ -1109,6 +1225,7 @@ function getExposedOpenAIClient(
 }
 
 function getReasoningParams(
+  astraRulesApply: boolean,
   baseReasoning: OpenAIClient.Reasoning | undefined,
   options?: ReasoningCallOptions
 ): OpenAIClient.Reasoning | undefined {
@@ -1134,18 +1251,19 @@ function getReasoningParams(
       effort: options.reasoningEffort,
     };
   }
-  return reasoning;
+  return substituteUnsupportedAstraEffort(astraRulesApply, reasoning);
 }
 
 function getGatedReasoningParams(
   model: string,
+  astraRulesApply: boolean,
   baseReasoning: OpenAIClient.Reasoning | undefined,
   options?: ReasoningCallOptions
 ): OpenAIClient.Reasoning | undefined {
   if (!isReasoningModel(model)) {
     return;
   }
-  return getReasoningParams(baseReasoning, options);
+  return getReasoningParams(astraRulesApply, baseReasoning, options);
 }
 
 function isObject(value: unknown): value is object {
@@ -1610,7 +1728,7 @@ export class CustomAzureOpenAIClient extends AzureOpenAIClient {
   }
 }
 
-const OFFICIAL_OPENAI_BASE_URL_PATTERN = /^https:\/\/api\.openai\.com(\/|$)/;
+const OFFICIAL_OPENAI_HOSTNAME = 'api.openai.com';
 
 /**
  * Official OpenAI (api.openai.com) and Azure OpenAI Chat Completions streams
@@ -1646,11 +1764,29 @@ function isOfficialOpenAIBaseURL(baseURL: string | null | undefined): boolean {
   if (effectiveBaseURL == null || effectiveBaseURL === '') {
     return true;
   }
-  return OFFICIAL_OPENAI_BASE_URL_PATTERN.test(effectiveBaseURL);
+  // Compared through the URL parser rather than textually: it normalizes the
+  // host case and drops the default :443, both of which spell the same
+  // first-party endpoint, while keeping a lookalike host such as
+  // `api.openai.com.example.net` a distinct hostname. A non-default port is
+  // someone else's listener, so it stays proxied.
+  let parsed: URL;
+  try {
+    parsed = new URL(effectiveBaseURL);
+  } catch {
+    return false;
+  }
+  return (
+    parsed.protocol === 'https:' &&
+    parsed.hostname === OFFICIAL_OPENAI_HOSTNAME &&
+    parsed.port === ''
+  );
 }
 
-const AZURE_FIRST_PARTY_BASE_PATH_PATTERN =
-  /^https:\/\/[^/]+\.(openai\.azure\.com|cognitiveservices\.azure\.com|api\.cognitive\.microsoft\.com)(:\d+)?(\/|$)/;
+const AZURE_FIRST_PARTY_HOST_SUFFIXES = [
+  '.openai.azure.com',
+  '.cognitiveservices.azure.com',
+  '.api.cognitive.microsoft.com',
+] as const;
 
 /**
  * Azure OpenAI is first-party when requests resolve to an instance-name
@@ -1670,10 +1806,59 @@ function isFirstPartyAzureEndpoint(args: {
   if (args.azureOpenAIBasePath == null || args.azureOpenAIBasePath === '') {
     return true;
   }
-  return AZURE_FIRST_PARTY_BASE_PATH_PATTERN.test(args.azureOpenAIBasePath);
+  // Parsed rather than matched textually, for the reason given on
+  // `isOfficialOpenAIBaseURL`: the host case carries no meaning, so an
+  // equivalent mixed-case spelling must not read as a proxy. Any port is
+  // accepted here, as the previous pattern did.
+  let parsed: URL;
+  try {
+    parsed = new URL(args.azureOpenAIBasePath);
+  } catch {
+    return false;
+  }
+  if (parsed.protocol !== 'https:') {
+    return false;
+  }
+  return AZURE_FIRST_PARTY_HOST_SUFFIXES.some((suffix) =>
+    parsed.hostname.endsWith(suffix)
+  );
+}
+
+/**
+ * Whether the GPT-6 Astra request-shaping rules apply to this request.
+ *
+ * Shaping only: which API serves the turn is the caller's decision, made where
+ * the rest of the request is shaped. These rules cover what the model rejects
+ * on either API — sampling and logprob parameters, unsupported reasoning
+ * efforts — plus the encrypted reasoning it supports.
+ *
+ * Both halves must hold: the SDK knows the model is Astra, and the caller has
+ * declared that this client talks to the first-party endpoint those rules
+ * describe. The endpoint half is *declared* rather than inferred from a base
+ * URL: only the caller knows whether a given URL is a faithful first-party
+ * route, a gateway, or a proxy with its own semantics, and every gate here
+ * removes capability — forcing Responses, dropping parameters, lowering effort
+ * — so guessing wrong silently degrades an endpoint the SDK cannot see.
+ *
+ * Defaults to off. An undeclared client keeps its existing behavior and a
+ * misconfigured Astra call fails with the provider's own error, which names the
+ * remedy, rather than being silently rewritten.
+ */
+function astraRulesApply(
+  model: string,
+  firstPartyEndpoint: boolean | undefined
+): boolean {
+  return firstPartyEndpoint === true && isGpt6AstraModel(model);
 }
 
 class LibreChatOpenAICompletions extends OriginalChatOpenAICompletions {
+  protected firstPartyEndpoint?: boolean;
+
+  /** @see {@link astraRulesApply} */
+  protected get astraRulesApply(): boolean {
+    return astraRulesApply(this.model, this.firstPartyEndpoint);
+  }
+
   private includeReasoningContent?: boolean;
   private includeReasoningDetails?: boolean;
   private convertReasoningDetailsToContent?: boolean;
@@ -1689,6 +1874,7 @@ class LibreChatOpenAICompletions extends OriginalChatOpenAICompletions {
       fields?.convertReasoningDetailsToContent;
     this.preserveToolCacheControl = fields?.preserveToolCacheControl;
     this.promptCacheExplicit = fields?.promptCacheExplicit;
+    this.firstPartyEndpoint = fields?.firstPartyEndpoint;
     this.safetyIdentifier = fields?.safety_identifier;
   }
 
@@ -1697,17 +1883,21 @@ class LibreChatOpenAICompletions extends OriginalChatOpenAICompletions {
     extra?: { streaming?: boolean }
   ): ReturnType<OriginalChatOpenAICompletions['invocationParams']> {
     return stripIntentFromStrictTools(
-      applyManagedRequestParams(super.invocationParams(options, extra), {
-        promptCacheExplicit: this.promptCacheExplicit,
-        safetyIdentifier: this.safetyIdentifier,
-      })
+      stripUnsupportedAstraParams(
+        this.astraRulesApply,
+        applyManagedRequestParams(super.invocationParams(options, extra), {
+          promptCacheExplicit: this.promptCacheExplicit,
+          safetyIdentifier: this.safetyIdentifier,
+        }),
+        'completions'
+      )
     );
   }
 
   protected _getReasoningParams(
     options?: this['ParsedCallOptions']
   ): OpenAIClient.Reasoning | undefined {
-    return getReasoningParams(this.reasoning, options);
+    return getReasoningParams(this.astraRulesApply, this.reasoning, options);
   }
 
   _getClientOptions(
@@ -2099,6 +2289,13 @@ class LibreChatOpenAICompletions extends OriginalChatOpenAICompletions {
 }
 
 class LibreChatOpenAIResponses extends OriginalChatOpenAIResponses {
+  protected firstPartyEndpoint?: boolean;
+
+  /** @see {@link astraRulesApply} */
+  protected get astraRulesApply(): boolean {
+    return astraRulesApply(this.model, this.firstPartyEndpoint);
+  }
+
   private promptCacheExplicit?: boolean;
   private responsesPromptCache?: boolean;
   private responsesPromptCacheTtl?: PromptCacheTtl;
@@ -2107,6 +2304,7 @@ class LibreChatOpenAIResponses extends OriginalChatOpenAIResponses {
   constructor(fields?: LibreChatOpenAIFields) {
     super(fields);
     this.promptCacheExplicit = fields?.promptCacheExplicit;
+    this.firstPartyEndpoint = fields?.firstPartyEndpoint;
     this.responsesPromptCache = fields?.responsesPromptCache;
     this.responsesPromptCacheTtl = fields?.responsesPromptCacheTtl;
     this.safetyIdentifier = fields?.safety_identifier;
@@ -2146,7 +2344,7 @@ class LibreChatOpenAIResponses extends OriginalChatOpenAIResponses {
         cache_control: cacheControl,
       }),
     };
-    if (shouldIncludeEncryptedReasoning(this.model, params)) {
+    if (shouldIncludeEncryptedReasoning(this.model, params, this.astraRulesApply)) {
       params.include = [
         ...new Set([
           ...(params.include ?? []),
@@ -2154,7 +2352,9 @@ class LibreChatOpenAIResponses extends OriginalChatOpenAIResponses {
         ]),
       ];
     }
-    return stripIntentFromStrictTools(params);
+    return stripIntentFromStrictTools(
+      stripUnsupportedAstraParams(this.astraRulesApply, params, 'responses')
+    );
   }
 
   async completionWithRetry(
@@ -2237,7 +2437,7 @@ class LibreChatOpenAIResponses extends OriginalChatOpenAIResponses {
   protected _getReasoningParams(
     options?: this['ParsedCallOptions']
   ): OpenAIClient.Reasoning | undefined {
-    return getReasoningParams(this.reasoning, options);
+    return getReasoningParams(this.astraRulesApply, this.reasoning, options);
   }
 
   _getClientOptions(
@@ -2248,12 +2448,20 @@ class LibreChatOpenAIResponses extends OriginalChatOpenAIResponses {
 }
 
 class LibreChatAzureOpenAICompletions extends OriginalAzureChatOpenAICompletions {
+  protected firstPartyEndpoint?: boolean;
+
+  /** @see {@link astraRulesApply} */
+  protected get astraRulesApply(): boolean {
+    return astraRulesApply(this.model, this.firstPartyEndpoint);
+  }
+
   private promptCacheExplicit?: boolean;
   private safetyIdentifier?: string;
 
   constructor(fields?: LibreChatAzureOpenAIFields) {
     super(fields);
     this.promptCacheExplicit = fields?.promptCacheExplicit;
+    this.firstPartyEndpoint = fields?.firstPartyEndpoint;
     this.safetyIdentifier = fields?.safety_identifier;
   }
 
@@ -2262,17 +2470,26 @@ class LibreChatAzureOpenAICompletions extends OriginalAzureChatOpenAICompletions
     extra?: { streaming?: boolean }
   ): ReturnType<OriginalAzureChatOpenAICompletions['invocationParams']> {
     return stripIntentFromStrictTools(
-      applyManagedRequestParams(super.invocationParams(options, extra), {
-        promptCacheExplicit: this.promptCacheExplicit,
-        safetyIdentifier: this.safetyIdentifier,
-      })
+      stripUnsupportedAstraParams(
+        this.astraRulesApply,
+        applyManagedRequestParams(super.invocationParams(options, extra), {
+          promptCacheExplicit: this.promptCacheExplicit,
+          safetyIdentifier: this.safetyIdentifier,
+        }),
+        'completions'
+      )
     );
   }
 
   protected _getReasoningParams(
     options?: this['ParsedCallOptions']
   ): OpenAIClient.Reasoning | undefined {
-    return getGatedReasoningParams(this.model, this.reasoning, options);
+    return getGatedReasoningParams(
+      this.model,
+      this.astraRulesApply,
+      this.reasoning,
+      options
+    );
   }
 
   protected _convertCompletionsDeltaToBaseMessageChunk(
@@ -2386,12 +2603,20 @@ class LibreChatAzureOpenAICompletions extends OriginalAzureChatOpenAICompletions
 }
 
 class LibreChatAzureOpenAIResponses extends OriginalAzureChatOpenAIResponses {
+  protected firstPartyEndpoint?: boolean;
+
+  /** @see {@link astraRulesApply} */
+  protected get astraRulesApply(): boolean {
+    return astraRulesApply(this.model, this.firstPartyEndpoint);
+  }
+
   private promptCacheExplicit?: boolean;
   private safetyIdentifier?: string;
 
   constructor(fields?: LibreChatAzureOpenAIFields) {
     super(fields);
     this.promptCacheExplicit = fields?.promptCacheExplicit;
+    this.firstPartyEndpoint = fields?.firstPartyEndpoint;
     this.safetyIdentifier = fields?.safety_identifier;
   }
 
@@ -2402,7 +2627,7 @@ class LibreChatAzureOpenAIResponses extends OriginalAzureChatOpenAIResponses {
       promptCacheExplicit: this.promptCacheExplicit,
       safetyIdentifier: this.safetyIdentifier,
     });
-    if (shouldIncludeEncryptedReasoning(this.model, params)) {
+    if (shouldIncludeEncryptedReasoning(this.model, params, this.astraRulesApply)) {
       params.include = [
         ...new Set([
           ...(params.include ?? []),
@@ -2410,7 +2635,9 @@ class LibreChatAzureOpenAIResponses extends OriginalAzureChatOpenAIResponses {
         ]),
       ];
     }
-    return stripIntentFromStrictTools(params);
+    return stripIntentFromStrictTools(
+      stripUnsupportedAstraParams(this.astraRulesApply, params, 'responses')
+    );
   }
 
   async completionWithRetry(
@@ -2493,7 +2720,12 @@ class LibreChatAzureOpenAIResponses extends OriginalAzureChatOpenAIResponses {
   protected _getReasoningParams(
     options?: this['ParsedCallOptions']
   ): OpenAIClient.Reasoning | undefined {
-    return getGatedReasoningParams(this.model, this.reasoning, options);
+    return getGatedReasoningParams(
+      this.model,
+      this.astraRulesApply,
+      this.reasoning,
+      options
+    );
   }
 
   _getClientOptions(
@@ -2573,6 +2805,13 @@ function withLibreChatOpenAIFields(
 }
 
 export class ChatOpenAI extends OriginalChatOpenAI<t.ChatOpenAICallOptions> {
+  protected firstPartyEndpoint?: boolean;
+
+  /** @see {@link astraRulesApply} */
+  protected get astraRulesApply(): boolean {
+    return astraRulesApply(this.model, this.firstPartyEndpoint);
+  }
+
   _lc_stream_delay: number;
 
   constructor(
@@ -2580,6 +2819,7 @@ export class ChatOpenAI extends OriginalChatOpenAI<t.ChatOpenAICallOptions> {
   ) {
     super(withLibreChatOpenAIFields(fields));
     this._lc_stream_delay = resolveStreamDelay(fields?._lc_stream_delay);
+    this.firstPartyEndpoint = fields?.firstPartyEndpoint;
   }
 
   public get exposedClient(): CustomOpenAIClient {
@@ -2627,7 +2867,7 @@ export class ChatOpenAI extends OriginalChatOpenAI<t.ChatOpenAICallOptions> {
   getReasoningParams(
     options?: this['ParsedCallOptions']
   ): OpenAIClient.Reasoning | undefined {
-    return getReasoningParams(this.reasoning, options);
+    return getReasoningParams(this.astraRulesApply, this.reasoning, options);
   }
 
   protected _getReasoningParams(
@@ -2670,6 +2910,13 @@ export class ChatOpenAI extends OriginalChatOpenAI<t.ChatOpenAICallOptions> {
 }
 
 export class AzureChatOpenAI extends OriginalAzureChatOpenAI {
+  protected firstPartyEndpoint?: boolean;
+
+  /** @see {@link astraRulesApply} */
+  protected get astraRulesApply(): boolean {
+    return astraRulesApply(this.model, this.firstPartyEndpoint);
+  }
+
   _lc_stream_delay: number;
 
   constructor(fields?: LibreChatAzureOpenAIFields) {
@@ -2677,6 +2924,7 @@ export class AzureChatOpenAI extends OriginalAzureChatOpenAI {
     this.completions = new LibreChatAzureOpenAICompletions(fields);
     this.responses = new LibreChatAzureOpenAIResponses(fields);
     this._lc_stream_delay = resolveStreamDelay(fields?._lc_stream_delay);
+    this.firstPartyEndpoint = fields?.firstPartyEndpoint;
   }
 
   public get exposedClient(): CustomOpenAIClient {
@@ -2686,6 +2934,7 @@ export class AzureChatOpenAI extends OriginalAzureChatOpenAI {
       this._useResponsesApi(undefined)
     ) as CustomOpenAIClient;
   }
+
   static lc_name(): 'LibreChatAzureOpenAI' {
     return 'LibreChatAzureOpenAI';
   }
@@ -2696,7 +2945,12 @@ export class AzureChatOpenAI extends OriginalAzureChatOpenAI {
   getReasoningParams(
     options?: this['ParsedCallOptions']
   ): OpenAIClient.Reasoning | undefined {
-    return getGatedReasoningParams(this.model, this.reasoning, options);
+    return getGatedReasoningParams(
+      this.model,
+      this.astraRulesApply,
+      this.reasoning,
+      options
+    );
   }
 
   protected _getReasoningParams(

package/src/tools/search/format.ts

@@ -11,6 +11,9 @@ const DEFAULT_MAX_LLM_OUTPUT_CHARS = 50000;
  *  this we drop it whole rather than emit a useless sliver. */
 const MIN_PARTIAL_HIGHLIGHT_CHARS = 200;
 
+export const MISSING_SEARCH_RESULT_DATA_ERROR =
+  'Search provider returned no result data';
+
 /** Resolves the per-search highlight budget from config, the
  *  `SEARCH_MAX_LLM_OUTPUT_CHARS` env var, or the default (50,000 chars). */
 export function resolveMaxLLMOutputChars(maxOutputChars?: number): number {
@@ -219,9 +222,16 @@ function formatSource(
 
 export function formatResultsForLLM(
   turn: number,
-  results: t.SearchResultData,
+  results?: t.SearchResultData | null,
   maxOutputChars?: number
 ): { output: string; references: t.ResultReference[] } {
+  if (results == null) {
+    return {
+      output: `Search failed: ${MISSING_SEARCH_RESULT_DATA_ERROR}`,
+      references: [],
+    };
+  }
+
   /** Bound highlight content to the per-search budget before formatting */
   const trimmedHighlights = trimHighlightsToBudget(
     results,
@@ -239,6 +249,10 @@ export function formatResultsForLLM(
 
   const references: t.ResultReference[] = [];
 
+  if (results.error != null && results.error !== '') {
+    outputLines.push(`Search failed: ${results.error}`);
+  }
+
   // Organic (web) results
   if (results.organic?.length != null && results.organic.length > 0) {
     addSection(`Web Results, Turn ${turn}`);

package/src/tools/search/tool.ts

@@ -21,7 +21,10 @@ import { INTENT_PROPERTY } from '@/tools/intentArg';
 import { createCrwScraper } from './crw-scraper';
 import { expandHighlights } from './highlights';
 import { createSearchMetrics } from './metrics';
-import { formatResultsForLLM } from './format';
+import {
+  formatResultsForLLM,
+  MISSING_SEARCH_RESULT_DATA_ERROR,
+} from './format';
 import { createDefaultLogger } from './utils';
 import { createReranker } from './rerankers';
 import { Constants } from '@/common';
@@ -66,6 +69,12 @@ export function resolveSearchOutcome(
   return `Found ${count} result${count === 1 ? '' : 's'} for "${query}"`;
 }
 
+export function normalizeSearchResultData(
+  result: t.SearchResultData | null | undefined
+): t.SearchResultData {
+  return result ?? { error: MISSING_SEARCH_RESULT_DATA_ERROR };
+}
+
 /** Distinct rows across the main search's two collections. SearXNG derives
  * both from one result array — a row matching its news heuristic lands in
  * `organic` and `topStories` alike — so summing the lengths would report
@@ -431,12 +440,13 @@ function createTool({
         }),
       });
       const turn = runnableConfig.toolCall?.turn ?? 0;
+      const resultData = normalizeSearchResultData(searchResult);
       const { output, references } = formatResultsForLLM(
         turn,
-        searchResult,
+        resultData,
         maxOutputChars
       );
-      const data: t.SearchResultData = { turn, ...searchResult, references };
+      const data: t.SearchResultData = { turn, ...resultData, references };
       const outcome = resolveSearchOutcome(data, query);
       return [
         output,

package/src/types/llm.ts

@@ -81,6 +81,29 @@ export type GoogleThinkingConfig = {
 export type ManagedRequestOptions = {
   promptCacheExplicit?: boolean;
   safety_identifier?: string;
+  /**
+   * Declares that this client talks to the first-party OpenAI or Azure surface.
+   * Gates the model-specific request *shaping* documented only for it —
+   * currently GPT-6 Astra's rejected sampling and logprob parameters, its
+   * unsupported reasoning efforts, and the encrypted reasoning it supports —
+   * and defaults to off.
+   *
+   * Shaping only. Which API serves the turn is not decided here: GPT-6 Astra
+   * serves tool calls only from the Responses API, and a caller wanting them
+   * must select it with `useResponsesApi`, alongside the rest of the request
+   * shaping that depends on which API is in use.
+   *
+   * The shaping runs inside this SDK's own request delegates. A caller that
+   * supplies its own `completions` or `responses` delegate replaces that
+   * construction and owns the request shaping for it — this flag cannot reach
+   * inside a delegate it did not build.
+   *
+   * Declared rather than inferred from a base URL: only the caller knows
+   * whether a URL is a faithful first-party route, a gateway, or a proxy with
+   * its own semantics, and every gate it controls removes capability, so
+   * guessing wrong silently degrades an endpoint the SDK cannot see.
+   */
+  firstPartyEndpoint?: boolean;
 };
 /**
  * Adaptive stream-smoothing configuration shared by every provider client.