@librechat/agents 3.2.57 → 3.2.59

package/dist/types/langfuseTraceShaping.d.ts

@@ -0,0 +1,20 @@
+import type { ReadableSpan } from '@opentelemetry/sdk-trace-base';
+/**
+ * LangGraph plumbing observations that add noise without information:
+ * the duplicated `__start__` channel-seed nodes and anonymous
+ * `RunnableLambda` pass-throughs (Langfuse team feedback items 4 & 5).
+ */
+export declare function shouldDropLangfuseSpan(spanName: string): boolean;
+/**
+ * Reshapes spans per Langfuse-team feedback before export:
+ * - `agent=<id>` / `tools=<id>` node names carry the ephemeral agent id
+ *   (`provider__model`) — strip it so switching models doesn't break
+ *   name-based logic (item 1).
+ * - Tool node spans are renamed to the actual tool name(s) and their
+ *   input scoped to the pending tool-call args instead of the whole
+ *   chat history (items 3 & 4).
+ * - The root span (and trace) input/output become the user question and
+ *   assistant response so the session view reads as a conversation
+ *   (item 2).
+ */
+export declare function shapeLangfuseSpan(span: ReadableSpan): void;

package/dist/types/tools/BashExecutor.d.ts

@@ -19,6 +19,15 @@ export declare const BashExecutionToolSchema: {
     readonly required: readonly ["command"];
 };
 export declare const BashExecutionToolDescription: string;
+/**
+ * Bash statefulness is filesystem-tier: on a warm session the machine (files
+ * including /tmp, installed packages, background processes) persists between
+ * calls, but each call may start a fresh shell — so shell variables and cwd
+ * are NOT reliable, and the machine can be reset at any time. Only /mnt/data
+ * is durable.
+ */
+export declare const STATEFUL_BASH_NOTE = "Session state (best-effort): commands in this conversation usually run on the same machine, so files (including /tmp), installed packages, and running background processes from earlier calls typically persist. Each call may still start a fresh shell \u2014 do not rely on shell variables or the working directory carrying over \u2014 and the machine may be reset at any time. Only /mnt/data is durable.";
+export declare const StatefulBashExecutionToolDescription: string;
 /**
  * Supplemental prompt documenting the tool-output reference feature.
  *
@@ -39,7 +48,11 @@ export declare const BashToolOutputReferencesGuide: string;
  */
 export declare function buildBashExecutionToolDescription(options?: {
     enableToolOutputReferences?: boolean;
+    statefulSessions?: boolean;
 }): string;
+export declare function buildBashExecutionToolSchema(opts?: {
+    statefulSessions?: boolean;
+}): typeof BashExecutionToolSchema;
 export declare const BashExecutionToolName = Constants.BASH_TOOL;
 /**
  * Default bash tool definition using the base description.

package/dist/types/tools/CodeExecutor.d.ts

@@ -38,6 +38,20 @@ export declare function buildCodeApiHttpErrorMessage(method: string, endpoint: s
     text: () => Promise<string>;
 }): Promise<string>;
 export declare const CodeExecutionToolDescription: string;
+/**
+ * Best-effort statefulness note. Deliberately hedged: warm reuse is an
+ * optimization, not a guarantee (the runtime may be reset on idle timeout,
+ * eviction, or the 8h VM lifetime), so the model must never depend on carried
+ * state for correctness and must persist anything durable to /mnt/data.
+ */
+export declare const STATEFUL_ENV_NOTE = "Session state (best-effort): consecutive executions in this conversation usually share one runtime, so variables, imports, and in-memory data from earlier successful calls are typically still available. The runtime may be reset at any time, so treat carried-over state as an optimization, never a guarantee. Anything that must survive MUST be written to /mnt/data. If a NameError/ImportError signals lost state, re-run the needed setup and continue.";
+export declare const StatefulCodeExecutionToolDescription: string;
+export declare function buildCodeExecutionToolDescription(opts?: {
+    statefulSessions?: boolean;
+}): string;
+export declare function buildCodeExecutionToolSchema(opts?: {
+    statefulSessions?: boolean;
+}): typeof CodeExecutionToolSchema;
 export declare const CodeExecutionToolName = Constants.EXECUTE_CODE;
 export declare const CodeExecutionToolDefinition: {
     readonly name: Constants.EXECUTE_CODE;

package/dist/types/tools/ToolNode.d.ts

@@ -314,6 +314,9 @@ export declare class ToolNode<T = any> extends RunnableCallable<T, T> {
      * opt-in so only host-declared tools can influence the shared session.
      */
     private participatesInCodeSession;
+    /** Delegates to the shared resolver so the direct and event-driven planning
+     *  paths derive the runtime session hint identically. */
+    private resolveRuntimeSessionHint;
     private storeCodeSessionFromResults;
     /**
      * Post-processes standard runTool outputs: dispatches ON_RUN_STEP_COMPLETED

package/dist/types/tools/eagerEventExecution.d.ts

@@ -9,7 +9,15 @@ export type ToolExecutionPlanCall = {
     args: unknown;
     stepId?: string;
     codeSessionContext?: t.ToolCallRequest['codeSessionContext'];
+    runtimeSessionHint?: string;
 };
+/**
+ * Stateful runtime session hint for the remote sandbox: only when
+ * `toolExecution.sandbox.statefulSessions` is on; explicit host hint else the
+ * conversation `thread_id`. Undefined disables the wire field. Shared by the
+ * direct ToolNode path and both event-driven planners so they stay in lockstep.
+ */
+export declare function resolveRuntimeSessionHint(toolExecution: t.ToolExecutionConfig | undefined, threadId: string | undefined): string | undefined;
 export type ToolExecutionRequestPlan = {
     allRequests: t.ToolCallRequest[];
     requests: t.ToolCallRequest[];

package/dist/types/tools/search/keenable-search.d.ts

@@ -0,0 +1,4 @@
+import type * as t from './types';
+export declare const createKeenableAPI: (apiKey?: string, apiUrl?: string, options?: t.KeenableSearchOptions) => {
+    getSources: (params: t.GetSourcesParams) => Promise<t.SearchResult>;
+};

package/dist/types/tools/search/rerankers.d.ts

@@ -8,16 +8,20 @@ export declare abstract class BaseReranker {
 }
 export declare class JinaReranker extends BaseReranker {
     private apiUrl;
-    constructor({ apiKey, apiUrl, logger, }: {
+    private timeout;
+    constructor({ apiKey, apiUrl, timeout, logger, }: {
         apiKey?: string;
         apiUrl?: string;
+        timeout?: number;
         logger?: t.Logger;
     });
     rerank(query: string, documents: string[], topK?: number): Promise<t.Highlight[]>;
 }
 export declare class CohereReranker extends BaseReranker {
-    constructor({ apiKey, logger, }: {
+    private timeout;
+    constructor({ apiKey, timeout, logger, }: {
         apiKey?: string;
+        timeout?: number;
         logger?: t.Logger;
     });
     rerank(query: string, documents: string[], topK?: number): Promise<t.Highlight[]>;
@@ -34,5 +38,6 @@ export declare const createReranker: (config: {
     jinaApiKey?: string;
     jinaApiUrl?: string;
     cohereApiKey?: string;
+    rerankerTimeout?: number;
     logger?: t.Logger;
 }) => BaseReranker | undefined;

package/dist/types/tools/search/types.d.ts

@@ -2,7 +2,7 @@ import type { RunnableConfig } from '@langchain/core/runnables';
 import type { Logger as WinstonLogger } from 'winston';
 import type { BaseReranker } from './rerankers';
 import { DATE_RANGE } from './schema';
-export type SearchProvider = 'serper' | 'searxng' | 'tavily';
+export type SearchProvider = 'serper' | 'searxng' | 'tavily' | 'keenable';
 export type ScraperProvider = 'firecrawl' | 'serper' | 'tavily';
 export type RerankerType = 'infinity' | 'jina' | 'cohere' | 'none';
 export interface Highlight {
@@ -100,6 +100,32 @@ export interface SearchConfig {
     tavilySearchUrl?: string;
     tavilyExtractUrl?: string;
     tavilySearchOptions?: TavilySearchOptions;
+    keenableApiKey?: string;
+    keenableApiUrl?: string;
+    keenableSearchOptions?: KeenableSearchOptions;
+}
+export interface KeenableSearchOptions {
+    maxResults?: number;
+    /** Restrict results to a single domain, e.g. "github.com". */
+    site?: string;
+    /** Sent as the X-Keenable-Title attribution header. Defaults to "LibreChat". */
+    attributionTitle?: string;
+    timeout?: number;
+}
+export interface KeenableSearchPayload {
+    query: string;
+    site?: string;
+    published_after?: string;
+}
+export interface KeenableSearchResult {
+    title?: string;
+    url?: string;
+    description?: string;
+    snippet?: string;
+    published_at?: string;
+}
+export interface KeenableSearchResponse {
+    results?: KeenableSearchResult[];
 }
 export type References = {
     links: MediaReference[];
@@ -120,6 +146,15 @@ export interface ProcessSourcesConfig {
      * chunker/reranker. Defaults to 50,000; also configurable via the
      * `SEARCH_MAX_CONTENT_LENGTH` env var. */
     maxContentLength?: number;
+    /** Chunk size (chars) for splitting scraped content before reranking.
+     * Defaults to 150; also configurable via the `SEARCH_CHUNK_SIZE` env var.
+     * Larger chunks send fewer documents to the reranker (lower cost/latency);
+     * highlights are expanded ±300-450 chars around each hit either way. */
+    chunkSize?: number;
+    /** Overlap (chars) between adjacent chunks. Defaults to 50; also
+     * configurable via the `SEARCH_CHUNK_OVERLAP` env var. Clamped below
+     * `chunkSize`. */
+    chunkOverlap?: number;
     strategies?: string[];
     filterContent?: boolean;
     reranker?: BaseReranker;
@@ -202,6 +237,8 @@ export interface SearchToolConfig extends SearchConfig, ProcessSourcesConfig, Fi
     jinaApiUrl?: string;
     cohereApiKey?: string;
     rerankerType?: RerankerType;
+    /** Timeout (ms) for rerank API requests. Defaults to 10,000. */
+    rerankerTimeout?: number;
     scraperProvider?: ScraperProvider;
     scraperTimeout?: number;
     serperScraperOptions?: SerperScraperConfig;

package/dist/types/types/graph.d.ts

@@ -480,6 +480,28 @@ export interface AgentInputs {
     subagentConfigs?: SubagentConfig[];
     /** Maximum subagent nesting depth. Default 1 means top-level agents can spawn subagents but subagents cannot nest further. */
     maxSubagentDepth?: number;
+    /**
+     * Host-supplied tool instances that must execute IN-PROCESS inside the graph's
+     * ToolNode even when the run is event-driven (`toolDefinitions` non-empty). Each
+     * instance is bound to the model alongside the schema-only event tools and its
+     * name is marked direct, so calls bypass ON_TOOL_EXECUTE dispatch and run inside
+     * the Pregel task frame. This is the only execution mode where a tool body may
+     * raise a LangGraph `interrupt()` (e.g. a tool built on `askUserQuestion()`) —
+     * the host-side event handler runs outside the graph task, where `interrupt()`
+     * throws. Do NOT also list these tools in `toolDefinitions` (they would be bound
+     * twice). NOT inherited by SELF-SPAWNED subagent children (their config is a
+     * shallow spread of the parent's inputs, and child graphs compile without a
+     * checkpointer, so an interrupt-capable tool could never pause there) —
+     * `buildChildInputs` scrubs the inherited copy; an EXPLICIT child config that
+     * lists its own `graphTools` keeps them.
+     *
+     * Deliberately `GenericTool[]`, not `GraphTools`: the wider union admits
+     * schema-only shapes (OpenAI `BindToolsInput`, Google tool objects) that
+     * `initializeTools` cannot register in the ToolNode direct map — the model
+     * would bind a tool the SDK advertised as in-process but cannot execute.
+     * Every entry must be a real executable tool instance with a `name`.
+     */
+    graphTools?: GenericTool[];
 }
 export interface ContextPruningConfig {
     enabled?: boolean;

package/dist/types/types/tools.d.ts

@@ -278,6 +278,15 @@ export type CodeExecutionToolParams = undefined | {
     files?: CodeEnvFile[];
     /** Optional host-supplied Code API auth headers. */
     authHeaders?: CodeApiAuthHeaders;
+    /**
+     * Advertise best-effort stateful sessions in the tool description
+     * (variables/files may persist between calls, may reset). Prompt text
+     * only, and it must be set here because the description is bound to the
+     * LLM at construction time. Pair it with the run-scoped
+     * `toolExecution.sandbox.statefulSessions` gate, which drives the wire
+     * hint — set both from one flag so the prompt and the backend agree.
+     */
+    statefulSessions?: boolean;
 };
 export type CodeApiAuthHeaderMap = Record<string, string>;
 export type CodeApiAuthHeaders = CodeApiAuthHeaderMap | (() => CodeApiAuthHeaderMap | Promise<CodeApiAuthHeaderMap>);
@@ -326,6 +335,13 @@ export type ExecuteResult = {
     stdout: string;
     stderr: string;
     files?: FileRefs;
+    /**
+     * Durable runtime session id echoed by a stateful Code API backend
+     * (hash of tenant+user+hint). Additive; absent on stateless servers.
+     */
+    runtime_session_id?: string;
+    /** Whether this execution reused a warm runtime session or started fresh. */
+    runtime_status?: 'new' | 'reused';
 };
 /** JSON Schema type definition for tool parameters */
 export type JsonSchemaType = {
@@ -381,6 +397,12 @@ export type ToolCallRequest = {
         session_id: string;
         files?: CodeEnvFile[];
     };
+    /**
+     * Stable runtime session hint for stateful sandbox sessions. Orthogonal to
+     * `codeSessionContext` (which threads the transient exec-session for file
+     * continuity): the hint identifies the durable server-side runtime session.
+     */
+    runtimeSessionHint?: string;
 };
 /** Batch request containing ALL tool calls for a graph step */
 export type ToolExecuteBatchRequest = {
@@ -896,6 +918,31 @@ export type CloudflareSandboxExecutionConfig = {
     /** Run a fast per-file syntax check after successful edits/writes. */
     postEditSyntaxCheck?: LocalExecutionConfig['postEditSyntaxCheck'];
 };
+export type SandboxExecutionConfig = {
+    /**
+     * Opt into best-effort stateful runtime sessions on the remote Code API
+     * (its warm per-session MicroVM backend). This gate is run-scoped: it only
+     * controls the wire behavior (ToolNode injecting the session hint on
+     * execute_code/bash calls). The transport is otherwise unchanged.
+     *
+     * It does NOT change the model-facing tool description. Tool descriptions are
+     * bound to the LLM at construction time (`createCodeExecutionTool` /
+     * `createBashExecutionTool`), before this run config is applied inside the
+     * graph, so they can only be adjusted via the tools' own `statefulSessions`
+     * factory param. Set BOTH from one flag (as LibreChat does): with this on but
+     * the factory param off, the backend runs statefully while the model is still
+     * told the environment is stateless (non-corrupting — the model just won't
+     * exploit persistence).
+     */
+    statefulSessions?: boolean;
+    /**
+     * Stable identity for the runtime session (e.g. the conversation id). The
+     * server derives the real session id as hash(tenant, user, hint), so this
+     * is never a security boundary. Falls back to `configurable.thread_id` when
+     * omitted.
+     */
+    runtimeSessionHint?: string;
+};
 export type ToolExecutionConfig = {
     /** `sandbox` preserves the remote Code API behavior and is the default. */
     engine?: ToolExecutionEngine;
@@ -903,6 +950,8 @@ export type ToolExecutionConfig = {
     local?: LocalExecutionConfig;
     /** Cloudflare Sandbox execution settings used when `engine` is `cloudflare-sandbox`. */
     cloudflare?: CloudflareSandboxExecutionConfig;
+    /** Remote sandbox settings; applies when `engine` is `sandbox` or omitted. */
+    sandbox?: SandboxExecutionConfig;
 };
 export type ProgrammaticCache = {
     toolMap: ToolMap;
@@ -1005,6 +1054,9 @@ export type ProgrammaticExecutionResponse = {
     stdout?: string;
     stderr?: string;
     files?: FileRefs;
+    /** Durable runtime session echo from a stateful backend (additive). */
+    runtime_session_id?: string;
+    runtime_status?: 'new' | 'reused';
     /** Present when status='error' */
     error?: string;
 };
@@ -1015,6 +1067,9 @@ export type ProgrammaticExecutionArtifact = {
     /** Execution session — see `CodeSessionContext.session_id`. */
     session_id?: string;
     files?: FileRefs;
+    /** Durable runtime session echo from a stateful backend (additive). */
+    runtime_session_id?: string;
+    runtime_status?: 'new' | 'reused';
 };
 /** Parameters for creating a bash execution tool (same API as CodeExecutor, bash-only) */
 export type BashExecutionToolParams = CodeExecutionToolParams;
@@ -1062,6 +1117,9 @@ export type CodeExecutionArtifact = {
     /** Execution session — see `CodeSessionContext.session_id`. */
     session_id?: string;
     files?: FileRefs;
+    /** Durable runtime session echo from a stateful backend (additive). */
+    runtime_session_id?: string;
+    runtime_status?: 'new' | 'reused';
 };
 /**
  * Generic session context union type for different tool types.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents",
-  "version": "3.2.57",
+  "version": "3.2.59",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/esm/main.mjs",
   "types": "./dist/types/index.d.ts",

package/src/agents/AgentContext.ts

@@ -85,6 +85,7 @@ export class AgentContext {
       toolSchemaTokens,
       subagentConfigs,
       maxSubagentDepth,
+      graphTools,
     } = agentConfig;
 
     const agentContext = new AgentContext({
@@ -116,6 +117,14 @@ export class AgentContext {
     agentContext._sourceInputs = agentConfig;
     agentContext.subagentConfigs = subagentConfigs;
     agentContext.maxSubagentDepth = maxSubagentDepth;
+    /**
+     * Host-supplied direct tools (see `AgentInputs.graphTools`). Copied — never
+     * aliased — because the SDK later pushes graph-managed tools (handoff /
+     * subagent) into this same array and must not mutate the host's input.
+     */
+    if (graphTools && graphTools.length > 0) {
+      agentContext.graphTools = [...graphTools];
+    }
 
     if (initialSummary?.text != null && initialSummary.text !== '') {
       agentContext.setInitialSummary(

package/src/agents/__tests__/AgentContext.test.ts

@@ -42,6 +42,46 @@ describe('AgentContext', () => {
       schema: { type: 'object', properties: {} },
     }) as unknown as t.GenericTool;
 
+  describe('fromConfig — host-supplied graphTools', () => {
+    it('copies graphTools onto the context without aliasing the host array', () => {
+      const askTool = createMockTool('ask_user_question');
+      const hostGraphTools = [askTool];
+      const ctx = createBasicContext({
+        agentConfig: { graphTools: hostGraphTools },
+      });
+
+      expect(ctx.graphTools).toEqual([askTool]);
+      expect(ctx.graphTools).not.toBe(hostGraphTools);
+
+      /** The SDK pushes graph-managed tools (handoff/subagent) into this
+       *  array later — that must never mutate the host's input. */
+      (ctx.graphTools as t.GenericTool[]).push(createMockTool('subagent'));
+      expect(hostGraphTools).toHaveLength(1);
+    });
+
+    it('leaves graphTools undefined when the host supplies none (or an empty list)', () => {
+      expect(createBasicContext().graphTools).toBeUndefined();
+      expect(
+        createBasicContext({ agentConfig: { graphTools: [] } }).graphTools
+      ).toBeUndefined();
+    });
+
+    it('binds host graphTools to the model in event-driven mode', () => {
+      const askTool = createMockTool('ask_user_question');
+      const ctx = createBasicContext({
+        agentConfig: {
+          graphTools: [askTool],
+          toolDefinitions: [{ name: 'echo', description: 'host event tool' }],
+        },
+      });
+
+      const bound = ctx.getToolsForBinding() ?? [];
+      const names = (bound as Array<{ name?: string }>).map((t) => t.name);
+      expect(names).toContain('ask_user_question');
+      expect(names).toContain('echo');
+    });
+  });
+
   describe('System Runnable - Lazy Creation', () => {
     it('creates system runnable on first access', () => {
       const ctx = createBasicContext({

package/src/graphs/Graph.ts

@@ -1140,7 +1140,15 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
   getToolCount(): number {
     const context = this.agentContexts.get(this.defaultAgentId);
     return (
-      (context?.tools?.length ?? 0) + (context?.toolDefinitions?.length ?? 0)
+      (context?.tools?.length ?? 0) +
+      (context?.toolDefinitions?.length ?? 0) +
+      /**
+       * Graph-managed + host-supplied direct tools (handoff, subagent,
+       * `AgentInputs.graphTools`) are bound to the model and token-accounted,
+       * so a count that omits them under-reports the run's tool surface
+       * (Codex #289 P3).
+       */
+      (context?.graphTools?.length ?? 0)
     );
   }
 
@@ -1286,10 +1294,25 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
       graphTools && graphTools.length > 0
         ? [...baseTools, ...graphTools]
         : baseTools;
+    /**
+     * ToolNode treats a supplied `toolMap` as authoritative (it only derives
+     * one from `tools` when the param is undefined), so when graphTools force
+     * us to build a merged map here, an absent `currentToolMap` must be
+     * seeded from the BASE tools first — otherwise ordinary tools stay bound
+     * to the model but vanish from the execution map and every call to them
+     * fails as an unknown tool (Codex #289 round 2).
+     */
     const traditionalToolMap =
       graphTools && graphTools.length > 0
         ? new Map([
-          ...(currentToolMap ?? new Map()),
+          ...(currentToolMap ??
+              new Map(
+                baseTools
+                  .filter(
+                    (t): t is t.GenericTool & { name: string } => 'name' in t
+                  )
+                  .map((t) => [t.name, t] as [string, t.GenericTool])
+              )),
           ...graphTools
             .filter((t): t is t.GenericTool & { name: string } => 'name' in t)
             .map((t) => [t.name, t] as [string, t.GenericTool]),

package/src/graphs/__tests__/composition.smoke.test.ts

@@ -73,6 +73,59 @@ const expectCompiledWorkflow = (
 };
 
 describe('LangGraph composition smoke tests', () => {
+  it('getToolCount includes direct graph tools (host-supplied graphTools) alongside instances and definitions', () => {
+    const askLikeTool = { name: 'ask_user_question' } as unknown as NonNullable<
+      t.AgentInputs['graphTools']
+    >[number];
+    const graph = new StandardGraph({
+      runId: 'toolcount-smoke',
+      agents: [
+        {
+          ...makeAgent('agent'),
+          toolDefinitions: [
+            { name: 'evt1', description: 'event tool one' },
+            { name: 'evt2', description: 'event tool two' },
+          ],
+          graphTools: [askLikeTool],
+        },
+      ],
+    });
+    // 2 schema-only event tools + 1 in-process direct tool — all bound to the
+    // model and token-accounted, so all must be counted (Codex #289 P3).
+    expect(graph.getToolCount()).toBe(3);
+  });
+
+  it('keeps ordinary tools executable when graphTools are added without a host toolMap (traditional mode)', () => {
+    type HostTool = NonNullable<t.AgentInputs['graphTools']>[number];
+    const echoTool = { name: 'echo_tool' } as unknown as HostTool;
+    const askLikeTool = { name: 'ask_user_question' } as unknown as HostTool;
+    const graph = new StandardGraph({
+      runId: 'toolmap-merge-smoke',
+      agents: [
+        {
+          ...makeAgent('agent'),
+          tools: [echoTool],
+          graphTools: [askLikeTool],
+        },
+      ],
+    });
+    const agentContext = graph.agentContexts.get('agent');
+    const node = graph.initializeTools({
+      currentTools: agentContext?.tools,
+      currentToolMap: undefined,
+      agentContext,
+    });
+    /**
+     * ToolNode treats a provided toolMap as authoritative — if the merged map
+     * built for graphTools drops the base tools, they stay bound to the model
+     * but every call fails as an unknown tool (Codex #289 round 2).
+     */
+    const toolMap = (node as unknown as { toolMap: Map<string, unknown> })
+      .toolMap;
+    expect(toolMap.has('echo_tool')).toBe(true);
+    expect(toolMap.has('ask_user_question')).toBe(true);
+  });
+
   it('clears run-scoped eager tool state on reset', () => {
     const graph = new StandardGraph({
       runId: 'standard-eager-reset',

package/src/langfuseToolOutputTracing.ts

@@ -16,6 +16,10 @@ import {
   resolveLangfuseConfig,
   resolveToolOutputTracingConfig,
 } from '@/langfuseConfig';
+import {
+  shapeLangfuseSpan,
+  shouldDropLangfuseSpan,
+} from '@/langfuseTraceShaping';
 import { resolveToolOutputTracingConfigForSpan } from '@/langfuseRuntimeScope';
 
 export { LANGFUSE_TOOL_OUTPUT_REDACTION_TEXT, resolveLangfuseConfig };
@@ -407,6 +411,9 @@ class ToolOutputRedactingLangfuseSpanProcessor implements SpanProcessor {
   }
 
   onStart(span: Span, parentContext: Context): void {
+    if (shouldDropLangfuseSpan(span.name)) {
+      return;
+    }
     const config =
       resolveToolOutputTracingConfigForSpan(parentContext) ??
       this.fallbackConfig;
@@ -417,7 +424,11 @@ class ToolOutputRedactingLangfuseSpanProcessor implements SpanProcessor {
   }
 
   onEnd(span: ReadableSpan): void {
+    if (shouldDropLangfuseSpan(span.name)) {
+      return;
+    }
     classifyLangfuseToolNodeSpan(span);
+    shapeLangfuseSpan(span);
     const config = this.spanConfigs.get(span) ?? this.fallbackConfig;
     if (config != null) {
       redactLangfuseSpanToolOutputs(span, config);