@librechat/agents 3.3.3 → 3.3.5

package/src/tools/search/keenable-scraper.ts

@@ -0,0 +1,137 @@
+import axios from 'axios';
+import type * as t from './types';
+import { createDefaultLogger } from './utils';
+
+const DEFAULT_KEENABLE_SCRAPE_TIMEOUT = 15000;
+
+/** Keyed and keyless fetch endpoints. Keenable reads any URL as clean markdown
+ * without a key via the public endpoint; a key only lifts rate limits. */
+const KEENABLE_FETCH_API_URL = 'https://api.keenable.ai/v1/fetch';
+const KEENABLE_FETCH_PUBLIC_URL = 'https://api.keenable.ai/v1/fetch/public';
+
+export class KeenableScraper implements t.BaseScraper {
+  private apiKey: string | undefined;
+  private apiUrl: string;
+  private timeout: number;
+  private attributionTitle: string;
+  private logger: t.Logger;
+
+  constructor(config: t.KeenableScraperConfig = {}) {
+    const resolvedKey = config.apiKey ?? process.env.KEENABLE_API_KEY;
+    this.apiKey =
+      resolvedKey != null && resolvedKey !== '' ? resolvedKey : undefined;
+    this.apiUrl =
+      config.apiUrl ??
+      process.env.KEENABLE_FETCH_URL ??
+      (this.apiKey != null
+        ? KEENABLE_FETCH_API_URL
+        : KEENABLE_FETCH_PUBLIC_URL);
+    this.timeout = config.timeout ?? DEFAULT_KEENABLE_SCRAPE_TIMEOUT;
+    this.attributionTitle = config.attributionTitle ?? 'LibreChat';
+    this.logger = config.logger || createDefaultLogger();
+  }
+
+  private buildHeaders(): Record<string, string> {
+    /** X-Keenable-Title is used for traffic attribution and required on the
+     * keyless endpoint; the key only lifts rate limits, so it is sent only when
+     * present. */
+    const headers: Record<string, string> = {
+      'X-Keenable-Title': this.attributionTitle,
+    };
+    if (this.apiKey != null) {
+      headers['X-API-Key'] = this.apiKey;
+    }
+    return headers;
+  }
+
+  async scrapeUrl(
+    url: string,
+    options: t.KeenableScrapeOptions = {}
+  ): Promise<[string, t.KeenableScrapeResponse]> {
+    if (!url || !url.trim()) {
+      return [url, { success: false, error: 'URL cannot be empty' }];
+    }
+
+    try {
+      const response = await axios.get<t.KeenableFetchResult>(this.apiUrl, {
+        params: { url },
+        headers: this.buildHeaders(),
+        timeout: options.timeout ?? this.timeout,
+      });
+
+      const data = response.data;
+      const content = data.content ?? '';
+      if (!content) {
+        return [
+          url,
+          { success: false, error: 'Keenable Fetch returned no content' },
+        ];
+      }
+
+      return [
+        url,
+        {
+          success: true,
+          data: {
+            content,
+            title: data.title,
+            description: data.description,
+            url: data.url ?? url,
+          },
+        },
+      ];
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      return [
+        url,
+        {
+          success: false,
+          error: `Keenable Fetch API request failed: ${errorMessage}`,
+        },
+      ];
+    }
+  }
+
+  async scrapeUrls(
+    urls: string[],
+    options: t.KeenableScrapeOptions = {}
+  ): Promise<Array<[string, t.KeenableScrapeResponse]>> {
+    /** Keenable fetch is single-URL; run the batch concurrently. */
+    return Promise.all(urls.map((url) => this.scrapeUrl(url, options)));
+  }
+
+  extractContent(
+    response: t.KeenableScrapeResponse
+  ): [string, undefined | t.References] {
+    if (!response.success || !response.data) {
+      return ['', undefined];
+    }
+    /** Keenable returns clean markdown with no separate media arrays, so there
+     * are no structured references to surface. */
+    return [response.data.content, undefined];
+  }
+
+  extractMetadata(response: t.KeenableScrapeResponse): t.GenericScrapeMetadata {
+    if (!response.success || !response.data) {
+      return {};
+    }
+    const metadata: t.GenericScrapeMetadata = {};
+    if (response.data.title != null) {
+      metadata.title = response.data.title;
+    }
+    if (response.data.description != null && response.data.description !== '') {
+      metadata.description = response.data.description;
+    }
+    if (response.data.url != null) {
+      metadata.url = response.data.url;
+    }
+    return metadata;
+  }
+}
+
+export const createKeenableScraper = (
+  config: t.KeenableScraperConfig = {}
+): KeenableScraper => {
+  return new KeenableScraper(config);
+};

package/src/tools/search/tool.ts

@@ -13,6 +13,7 @@ import {
   DATE_RANGE,
 } from './schema';
 import { createSearchAPI, createSourceProcessor } from './search';
+import { createKeenableScraper } from './keenable-scraper';
 import { createSerperScraper } from './serper-scraper';
 import { createTavilyScraper } from './tavily-scraper';
 import { createFirecrawlScraper } from './firecrawl';
@@ -378,6 +379,7 @@ export const createSearchTool = (
     keenableApiKey,
     keenableApiUrl,
     keenableSearchOptions,
+    keenableScraperOptions,
     rerankerType = 'cohere',
     rerankerTimeout,
     topResults = 5,
@@ -476,13 +478,22 @@ export const createSearchTool = (
   } else if (scraperProvider === 'crw') {
     scraperInstance = createCrwScraper({
       ...crwScraperOptions,
-      apiKey:
-        crwScraperOptions?.apiKey ?? crwApiKey ?? process.env.CRW_API_KEY,
+      apiKey: crwScraperOptions?.apiKey ?? crwApiKey ?? process.env.CRW_API_KEY,
       apiUrl: crwScraperOptions?.apiUrl ?? crwApiUrl,
       timeout: scraperTimeout ?? crwScraperOptions?.timeout,
       formats: crwScraperOptions?.formats ?? ['markdown', 'rawHtml'],
       logger,
     });
+  } else if (scraperProvider === 'keenable') {
+    scraperInstance = createKeenableScraper({
+      ...keenableScraperOptions,
+      apiKey: keenableScraperOptions?.apiKey ?? keenableApiKey,
+      timeout: scraperTimeout ?? keenableScraperOptions?.timeout,
+      attributionTitle:
+        keenableScraperOptions?.attributionTitle ??
+        keenableSearchOptions?.attributionTitle,
+      logger,
+    });
   } else {
     scraperInstance = createFirecrawlScraper({
       ...firecrawlOptions,

package/src/tools/search/types.ts

@@ -3,8 +3,18 @@ import type { Logger as WinstonLogger } from 'winston';
 import type { BaseReranker } from './rerankers';
 import { DATE_RANGE } from './schema';
 
-export type SearchProvider = 'serper' | 'searxng' | 'tavily' | 'keenable' | 'crw';
-export type ScraperProvider = 'firecrawl' | 'serper' | 'tavily' | 'crw';
+export type SearchProvider =
+  | 'serper'
+  | 'searxng'
+  | 'tavily'
+  | 'keenable'
+  | 'crw';
+export type ScraperProvider =
+  | 'firecrawl'
+  | 'serper'
+  | 'tavily'
+  | 'crw'
+  | 'keenable';
 export type RerankerType = 'infinity' | 'jina' | 'cohere' | 'none';
 
 export interface Highlight {
@@ -198,6 +208,41 @@ export interface KeenableSearchResponse {
   results?: KeenableSearchResult[];
 }
 
+export interface KeenableScraperConfig {
+  apiKey?: string;
+  /** Override the fetch endpoint base (default: public keyless, keyed when a
+   * key is set). Env fallback: KEENABLE_FETCH_URL. */
+  apiUrl?: string;
+  timeout?: number;
+  logger?: Logger;
+  /** Sent as the X-Keenable-Title attribution header. Defaults to "LibreChat". */
+  attributionTitle?: string;
+}
+
+export type KeenableScrapeOptions = Omit<
+  KeenableScraperConfig,
+  'apiKey' | 'apiUrl' | 'logger'
+>;
+
+/** Raw JSON shape returned by GET /v1/fetch{,/public}?url=... */
+export interface KeenableFetchResult {
+  url?: string;
+  title?: string;
+  content?: string;
+  description?: string;
+}
+
+export interface KeenableScrapeResponse {
+  success: boolean;
+  data?: {
+    content: string;
+    title?: string;
+    description?: string;
+    url?: string;
+  };
+  error?: string;
+}
+
 export type References = {
   links: MediaReference[];
   images: MediaReference[];
@@ -311,6 +356,7 @@ export interface SearchToolConfig
     FirecrawlConfig {
   tavilyScraperOptions?: TavilyScraperConfig;
   crwScraperOptions?: CrwScraperConfig;
+  keenableScraperOptions?: KeenableScraperConfig;
   /** Max chars of highlight content this tool feeds the MODEL per search (the
    * dominant, otherwise-unbounded part of the output). Distinct from
    * `maxContentLength`, which caps scraped/reranked content per source — full
@@ -351,7 +397,8 @@ export type AnyScraperResponse =
   | FirecrawlScrapeResponse
   | SerperScrapeResponse
   | TavilyScrapeResponse
-  | CrwScrapeResponse;
+  | CrwScrapeResponse
+  | KeenableScrapeResponse;
 
 /** Base Scraper Interface */
 export interface BaseScraper {

package/src/tools/toolOutputReferences.ts

@@ -29,6 +29,7 @@ import {
   HARD_MAX_TOOL_RESULT_CHARS,
   HARD_MAX_TOTAL_TOOL_OUTPUT_SIZE,
 } from '@/utils/truncation';
+import { isComputerCallOutputMessage } from '@/utils/toolContent';
 
 /**
  * Non-global matcher for a single `{{tool<i>turn<n>}}` placeholder.
@@ -656,6 +657,11 @@ export function annotateMessagesForLLM(
     const hasRefScope = '_refScope' in meta;
     const hasUnresolvedField = '_unresolvedRefs' in meta;
     if (!hasRefKey && !hasRefScope && !hasUnresolvedField) continue;
+    if (isComputerCallOutputMessage(m)) {
+      out ??= messages.slice();
+      out[i] = cloneToolMessageWithContent(m as ToolMessage, m.content);
+      continue;
+    }
 
     const refKey = readRefKey(meta);
     const unresolved = readUnresolvedRefs(meta);

package/src/types/graph.ts

@@ -30,7 +30,11 @@ import type {
   MessageDeltaEvent,
   ReasoningDeltaEvent,
 } from '@/types/stream';
-import type { TokenCounter, TokenBudgetBreakdown } from '@/types/run';
+import type {
+  TokenCounter,
+  StreamPreemption,
+  TokenBudgetBreakdown,
+} from '@/types/run';
 import type { Providers, Callback, GraphNodeKeys } from '@/common';
 import type { StandardGraph, MultiAgentGraph } from '@/graphs';
 import type { ClientOptions } from '@/types/llm';
@@ -346,6 +350,13 @@ export type StandardGraphInput = {
    * hook inputs carry only `executingAgentId`.
    */
   subagentScope?: boolean;
+  /**
+   * Cooperative preemption, forwarded from `RunConfig.preemption`. Only ever
+   * set on the top-level graph: a steer targets the conversation, so subagent
+   * children must run to completion and `buildChildInputs` does not propagate
+   * this field.
+   */
+  preemption?: StreamPreemption;
 };
 
 export type GraphEdge = {

package/src/types/run.ts

@@ -115,6 +115,65 @@ export type StandardGraphConfig = Omit<
   'edges' | 'type'
 > & { type?: 'standard'; signal?: AbortSignal };
 
+/**
+ * Cooperative mid-generation preemption. Lets a host seal the live model
+ * stream at the next provider-safe token boundary — the run is never
+ * aborted, the partial assistant turn is kept, and the graph self-loops
+ * into a fresh model call once the `PreemptBoundary` hook has injected
+ * whatever the host queued.
+ *
+ * Preconditions the host MUST satisfy:
+ *   - `shouldPreempt` is polled once per streamed chunk on the top-level
+ *     graph. It must be synchronous, allocation-free and O(1) — never I/O.
+ *     It must also be LEVEL-TRIGGERED (non-consuming): the SDK never clears
+ *     the host's request, and a true result is only honored once the
+ *     accumulated chunk is provider-safe, so the predicate may be polled
+ *     many times before a seal. A one-shot read that clears its own pending
+ *     flag would silently lose the request on an unsafe chunk (leading
+ *     whitespace/reasoning, an in-flight tool call) — keep returning true
+ *     until the `PreemptBoundary` drain hands over the queued injection,
+ *     then disarm there.
+ *   - Sealing is only honored on the SDK's own dispatch loop. A run whose
+ *     registered `CHAT_MODEL_STREAM` handler IS the SDK dispatcher — or wraps
+ *     it, which `composeEventHandlers` and `createRunHandlers` both do —
+ *     consumes chunks through a decoupled `streamEvents` reader that can lag
+ *     the accumulated chunk, so those runs never seal.
+ *
+ *     Detection is by capability, not identity: the dispatcher carries
+ *     `SDK_STREAM_DISPATCH` and the SDK's wrappers propagate it. A handler
+ *     that merely OBSERVES the raw chunk echo — LibreChat's no-op
+ *     `OpenAIChatModelStreamHandler`, say — is unbranded and does NOT disable
+ *     sealing, because it assigns no content-part indices and so cannot be
+ *     inverted. A host that renders from the raw feed and wants the opt-out
+ *     should brand its handler with `SDK_STREAM_DISPATCH`.
+ *   - `RunConfig.tokenCounter` should be set. A sealed turn ends before most
+ *     providers send their usage chunk, so the synthetic `CHAT_MODEL_END`
+ *     falls back to the counter to report `output_tokens`. Without one that
+ *     fallback silently no-ops and the sealed turn's usage is lost — verified
+ *     live: OpenAI, Azure OpenAI and DeepSeek report no usage for the sealed
+ *     segment without a counter, while Anthropic streams usage incrementally
+ *     and reports it either way.
+ */
+export interface StreamPreemption {
+  /**
+   * Polled once per streamed chunk. Synchronous, allocation-free, O(1), and
+   * level-triggered — keep returning true until the `PreemptBoundary` drain
+   * consumes the request; a self-clearing read loses it on an unsafe chunk.
+   */
+  shouldPreempt: () => boolean;
+  /**
+   * Max cooperative seals per run. Each seal costs one extra superstep, so
+   * this also bounds the recursion-limit headroom the run reserves.
+   */
+  maxSeals?: number;
+}
+
+/** Seals honored and boundaries that had nothing to inject, per run. */
+export type PreemptStats = {
+  seals: number;
+  emptyBoundaries: number;
+};
+
 export type RunConfig = {
   runId: string;
   graphConfig: LegacyGraphConfig | StandardGraphConfig | MultiAgentGraphConfig;
@@ -146,6 +205,14 @@ export type RunConfig = {
    * block to prevent leaks.
    */
   hooks?: HookRegistry;
+  /**
+   * Opt-in cooperative preemption for this run. Requires a `hooks` registry
+   * with a `PreemptBoundary` matcher — the seal only stops the stream, the
+   * hook is what supplies the messages to resume with. Omit to keep the
+   * pre-preemption behavior, where a mid-run injection can only land at a
+   * tool boundary.
+   */
+  preemption?: StreamPreemption;
   returnContent?: boolean;
   tokenCounter?: TokenCounter;
   indexTokenCountMap?: Record<string, number>;

package/src/types/stream.ts

@@ -8,7 +8,6 @@ import type {
 import type { ToolCall, ToolCallChunk } from '@langchain/core/messages/tool';
 import type { LLMResult, Generation } from '@langchain/core/outputs';
 import type { Command } from '@langchain/langgraph';
-import type OpenAITypes from 'openai';
 import type { AnthropicContentBlock } from '@/llm/anthropic/types';
 import type { SummarizeCompleteEvent } from '@/types/summarize';
 import type { ToolEndEvent } from '@/types/tools';
@@ -336,7 +335,7 @@ export type ToolCallPart = {
   /** If provided, an identifier associated with the tool call */
   id?: string;
   /** If provided, the output of the tool call */
-  output?: string;
+  output?: ToolResultContent['content'];
   /** Auth URL */
   auth?: string;
   /** Expiration time */
@@ -393,46 +392,6 @@ export interface TMessage {
 
 export type TPayload = Array<Partial<TMessage>>;
 
-export type CustomChunkDelta =
-  | null
-  | undefined
-  | (Partial<OpenAITypes.Chat.Completions.ChatCompletionChunk.Choice.Delta> & {
-      reasoning?: string | null;
-      reasoning_content?: string | null;
-    });
-export type CustomChunkChoice = Partial<
-  Omit<OpenAITypes.Chat.Completions.ChatCompletionChunk.Choice, 'delta'> & {
-    delta?: CustomChunkDelta;
-  }
->;
-export type CustomChunk = Partial<OpenAITypes.ChatCompletionChunk> & {
-  choices?: Partial<Array<CustomChunkChoice>>;
-};
-
-export type SplitStreamHandlers = Partial<{
-  [GraphEvents.ON_RUN_STEP]: ({
-    event,
-    data,
-  }: {
-    event: GraphEvents;
-    data: RunStep;
-  }) => void;
-  [GraphEvents.ON_MESSAGE_DELTA]: ({
-    event,
-    data,
-  }: {
-    event: GraphEvents;
-    data: MessageDeltaEvent;
-  }) => void;
-  [GraphEvents.ON_REASONING_DELTA]: ({
-    event,
-    data,
-  }: {
-    event: GraphEvents;
-    data: ReasoningDeltaEvent;
-  }) => void;
-}>;
-
 export type SummarizeDeltaData = {
   id: string;
   delta: {

package/src/utils/llm.test.ts

@@ -0,0 +1,18 @@
+import { isAnthropicLike } from './llm';
+import { Providers } from '@/common';
+
+describe('isAnthropicLike', () => {
+  it('treats the default Bedrock model as Claude', () => {
+    expect(isAnthropicLike(Providers.BEDROCK)).toBe(true);
+    expect(
+      isAnthropicLike(Providers.BEDROCK, {
+        model: 'anthropic.claude-sonnet-4-5',
+      })
+    ).toBe(true);
+    expect(
+      isAnthropicLike(Providers.BEDROCK, {
+        model: 'amazon.nova-pro-v1:0',
+      })
+    ).toBe(false);
+  });
+});

package/src/utils/llm.ts

@@ -32,7 +32,10 @@ export function isAnthropicLike(
 ): boolean {
   if (provider === Providers.ANTHROPIC) return true;
   if (provider === Providers.BEDROCK) {
-    return /claude/i.test(String(clientOptions?.model ?? ''));
+    return (
+      clientOptions?.model == null ||
+      /claude/i.test(String(clientOptions.model))
+    );
   }
   return false;
 }