@librechat/agents 3.1.86 → 3.1.88

package/dist/types/session/JsonlSessionStore.d.ts

@@ -0,0 +1,67 @@
+import type { CreateSessionFileOptions, SessionBranchOptions, SessionEntry, SessionForkOptions, SessionHeader, SessionLabelEntry, SessionListItem, SessionMessageEntry, SessionCheckpointEntry, SessionCompactionEntry, SessionRunEventEntry, SessionSummaryEntry, SessionStateEntry, SessionTreeNode } from './types';
+import type { BaseMessage } from '@langchain/core/messages';
+export declare class JsonlSessionStore {
+    readonly path: string;
+    readonly header: SessionHeader;
+    private entries;
+    private constructor();
+    static getDefaultRoot(): string;
+    static create(options: CreateSessionFileOptions & {
+        path?: string;
+    }): Promise<JsonlSessionStore>;
+    static open(pathOrId: string): Promise<JsonlSessionStore>;
+    static openPath(path: string): Promise<JsonlSessionStore>;
+    static resolvePath(pathOrId: string): Promise<string>;
+    static list(cwd: string): Promise<SessionListItem[]>;
+    static listAll(root?: string): Promise<SessionListItem[]>;
+    private static listDirectory;
+    getEntries(): SessionEntry[];
+    getEntry(id: string): SessionEntry | undefined;
+    getChildren(id: string): SessionEntry[];
+    getTree(): SessionTreeNode[];
+    getLeafEntry(): SessionEntry | undefined;
+    getPath(entryId?: string | undefined): SessionEntry[];
+    getMessages(entryId?: string): BaseMessage[];
+    getForkPoints(): SessionMessageEntry[];
+    getLabel(entryId: string): string | undefined;
+    setLabel(entryId: string, label: string): Promise<SessionLabelEntry>;
+    appendMessage(message: BaseMessage, parentId?: string | null): Promise<SessionMessageEntry>;
+    appendRunEvent(event: string, payload?: unknown, params?: {
+        runId?: string;
+        threadId?: string;
+    }): Promise<SessionRunEventEntry>;
+    setLeaf(leafId: string | null): Promise<SessionStateEntry>;
+    appendEntryForCompaction(params: {
+        text: string;
+        tokenCount?: number;
+        retainedEntryIds: string[];
+        summarizedEntryIds: string[];
+        instructions?: string;
+        parentId?: string | null;
+    }): Promise<SessionSummaryEntry>;
+    appendCompactionEntry(params: {
+        summaryEntryId: string;
+        retainedEntryIds: string[];
+        summarizedEntryIds: string[];
+    }): Promise<SessionCompactionEntry>;
+    appendCheckpoint(params: {
+        source: SessionCheckpointEntry['data']['source'];
+        threadId: string;
+        runId?: string;
+        checkpointId?: string;
+        checkpointNs?: string;
+        parentCheckpointId?: string;
+        reason?: string;
+    }): Promise<SessionCheckpointEntry>;
+    getCheckpoints(threadId?: string): SessionCheckpointEntry[];
+    getLatestCheckpoint(threadId?: string): SessionCheckpointEntry | undefined;
+    branch(entryId: string, options?: SessionBranchOptions): Promise<SessionEntry | undefined>;
+    createBranchedSession(entryId?: string | undefined, options?: SessionForkOptions): Promise<JsonlSessionStore>;
+    clone(options?: SessionForkOptions): Promise<JsonlSessionStore>;
+    fork(entryId: string, options?: SessionForkOptions): Promise<JsonlSessionStore>;
+    private getBranchTarget;
+    private appendExistingEntry;
+    private appendEntry;
+    existsOnDisk(): Promise<boolean>;
+}
+export declare const SessionManager: typeof JsonlSessionStore;

package/dist/types/session/handlers.d.ts

@@ -0,0 +1,8 @@
+import type * as t from '@/types';
+import type { AgentSessionHandlersResult, AgentSessionStreamEvent } from './types';
+export declare function createRunHandlers(params: {
+    runId: string;
+    threadId: string;
+    userHandlers?: Record<string, t.EventHandler>;
+    onEvent?: (event: AgentSessionStreamEvent) => void;
+}): AgentSessionHandlersResult;

package/dist/types/session/ids.d.ts

@@ -0,0 +1,4 @@
+export declare function createSessionId(): string;
+export declare function createEntryId(): string;
+export declare function createRunId(): string;
+export declare function createTimestamp(): string;

package/dist/types/session/index.d.ts

@@ -0,0 +1,5 @@
+export { AgentSession, createAgentSession } from './AgentSession';
+export { JsonlSessionStore, SessionManager } from './JsonlSessionStore';
+export { createRunHandlers } from './handlers';
+export { serializeMessage, deserializeMessage, extractTextFromContent, } from './messageSerialization';
+export type { AgentSessionConfig, AgentSessionCheckpointLookupOptions, AgentSessionCheckpointReference, AgentSessionCheckpointing, AgentSessionCheckpointingOptions, AgentSessionHandlersResult, AgentSessionInput, AgentSessionRunOptions, AgentSessionRunResult, AgentSessionStream, AgentSessionStreamEvent, AgentSessionUsage, CreateSessionFileOptions, JsonObject, JsonPrimitive, JsonValue, SerializedSessionMessage, SessionBranchOptions, SessionCompactOptions, SessionCheckpointEntry, SessionCompactionEntry, SessionEntry, SessionEntryBase, SessionEntryType, SessionForkOptions, SessionHeader, SessionLabelEntry, SessionListItem, SessionMessageEntry, SessionPosition, SessionRunEventEntry, SessionStateEntry, SessionSummaryEntry, SessionTreeNode, } from './types';

package/dist/types/session/messageSerialization.d.ts

@@ -0,0 +1,7 @@
+import { BaseMessage } from '@langchain/core/messages';
+import type { JsonValue, SerializedSessionMessage } from './types';
+export declare function toJsonValue(value: unknown): JsonValue;
+export declare function serializeMessage(message: BaseMessage): SerializedSessionMessage;
+export declare function deserializeMessage(serialized: SerializedSessionMessage): BaseMessage;
+export declare function getMessageRole(message: BaseMessage): string;
+export declare function extractTextFromContent(content: JsonValue): string;

package/dist/types/session/types.d.ts

@@ -0,0 +1,191 @@
+import type { RunnableConfig } from '@langchain/core/runnables';
+import type { BaseMessage } from '@langchain/core/messages';
+import type { BaseCheckpointSaver } from '@langchain/langgraph';
+import type * as t from '@/types';
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export type JsonObject = {
+    [key: string]: JsonValue;
+};
+export type SessionEntryType = 'message' | 'summary' | 'compaction' | 'checkpoint' | 'label' | 'run_event' | 'session_state';
+export interface SessionHeader {
+    type: 'session';
+    version: 1;
+    id: string;
+    timestamp: string;
+    cwd: string;
+    name?: string;
+    parentSession?: string;
+}
+export interface SessionEntryBase<TType extends SessionEntryType, TData> {
+    type: TType;
+    id: string;
+    parentId: string | null;
+    timestamp: string;
+    data: TData;
+}
+export interface SerializedSessionMessage {
+    messageType: string;
+    content: JsonValue;
+    additionalKwargs?: JsonObject;
+    responseMetadata?: JsonObject;
+    id?: string;
+    name?: string;
+    toolCallId?: string;
+    toolCalls?: JsonValue;
+    usageMetadata?: JsonObject;
+}
+export type SessionMessageEntry = SessionEntryBase<'message', {
+    role: string;
+    message: SerializedSessionMessage;
+}>;
+export type SessionSummaryEntry = SessionEntryBase<'summary', {
+    text: string;
+    tokenCount?: number;
+    retainedEntryIds: JsonValue[];
+    summarizedEntryIds: JsonValue[];
+    instructions?: string;
+}>;
+export type SessionCompactionEntry = SessionEntryBase<'compaction', {
+    summaryEntryId: string;
+    retainedEntryIds: JsonValue[];
+    summarizedEntryIds: JsonValue[];
+}>;
+export type SessionCheckpointEntry = SessionEntryBase<'checkpoint', {
+    provider: 'langgraph';
+    source: 'run' | 'resume' | 'reset';
+    threadId: string;
+    runId?: string;
+    checkpointId?: string;
+    checkpointNs?: string;
+    parentCheckpointId?: string;
+    reason?: string;
+}>;
+export type SessionLabelEntry = SessionEntryBase<'label', {
+    targetEntryId: string;
+    label: string;
+}>;
+export type SessionRunEventEntry = SessionEntryBase<'run_event', {
+    event: string;
+    runId?: string;
+    threadId?: string;
+    payload?: JsonValue;
+}>;
+export type SessionStateEntry = SessionEntryBase<'session_state', {
+    leafId: string | null;
+}>;
+export type SessionEntry = SessionMessageEntry | SessionSummaryEntry | SessionCompactionEntry | SessionCheckpointEntry | SessionLabelEntry | SessionRunEventEntry | SessionStateEntry;
+export interface SessionTreeNode {
+    entry: SessionEntry;
+    children: SessionTreeNode[];
+}
+export interface SessionListItem {
+    id: string;
+    path: string;
+    cwd: string;
+    timestamp: string;
+    name?: string;
+    leafId?: string | null;
+}
+export type SessionPosition = 'before' | 'at';
+export interface SessionForkOptions {
+    position?: SessionPosition;
+    cwd?: string;
+    name?: string;
+}
+export interface SessionBranchOptions {
+    position?: SessionPosition;
+    summarizeAbandoned?: boolean | {
+        instructions?: string;
+    };
+}
+export interface SessionCompactOptions {
+    instructions?: string;
+    retainRecentTurns?: number;
+}
+export interface AgentSessionRunResult {
+    text: string;
+    content: t.MessageContentComplex[];
+    messages: BaseMessage[];
+    usage: AgentSessionUsage;
+    steps: t.RunStep[];
+    interrupt: t.RunInterruptResult | undefined;
+    haltedReason: string | undefined;
+    runId: string;
+    threadId: string;
+}
+export interface AgentSessionUsage {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+}
+export interface AgentSessionCheckpointReference {
+    provider: 'langgraph';
+    threadId: string;
+    checkpointId?: string;
+    checkpointNs?: string;
+    parentCheckpointId?: string;
+}
+export interface AgentSessionCheckpointLookupOptions {
+    threadId?: string;
+    checkpointNs?: string;
+    config?: RunnableConfig;
+}
+export interface AgentSessionCheckpointingOptions {
+    enabled?: boolean;
+    checkpointer?: BaseCheckpointSaver;
+}
+export type AgentSessionCheckpointing = boolean | AgentSessionCheckpointingOptions;
+export type AgentSessionInput = string | BaseMessage | BaseMessage[] | t.IState;
+export interface AgentSessionRunOptions {
+    runId?: string;
+    threadId?: string;
+    config?: Partial<RunnableConfig> & {
+        version?: 'v1' | 'v2';
+    };
+    streamOptions?: t.EventStreamOptions;
+}
+export interface AgentSessionStreamEvent {
+    type: 'run.started' | 'message.delta' | 'reasoning.delta' | 'tool.started' | 'tool.delta' | 'tool.completed' | 'usage.updated' | 'run.completed' | 'run.failed' | 'run.interrupted' | 'run.halted';
+    sequence: number;
+    runId: string;
+    threadId: string;
+    timestamp: string;
+    data?: JsonValue;
+}
+export interface AgentSessionStream extends AsyncIterable<AgentSessionStreamEvent> {
+    toTextStream(): AsyncIterable<string>;
+    finalResult(): Promise<AgentSessionRunResult>;
+}
+export interface AgentSessionHandlersResult {
+    contentParts: Array<t.MessageContentComplex | undefined>;
+    steps: t.RunStep[];
+    usage: AgentSessionUsage;
+    events: AgentSessionStreamEvent[];
+    handlers: Record<string, t.EventHandler>;
+}
+export type AgentSessionConfig = {
+    runConfig: t.RunConfig;
+    cwd?: string;
+    sessionPath?: string;
+    sessionId?: string;
+    name?: string;
+    ephemeral?: boolean;
+    checkpointing?: AgentSessionCheckpointing;
+} | ({
+    runId?: string;
+    cwd?: string;
+    sessionPath?: string;
+    sessionId?: string;
+    name?: string;
+    ephemeral?: boolean;
+    checkpointing?: AgentSessionCheckpointing;
+} & Omit<t.RunConfig, 'runId'>);
+export interface CreateSessionFileOptions {
+    cwd: string;
+    name?: string;
+    parentSession?: string;
+    sessionId?: string;
+}

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

@@ -80,6 +80,12 @@ export declare class ToolNode<T = any> extends RunnableCallable<T, T> {
     private sessions?;
     /** When true, dispatches ON_TOOL_EXECUTE events instead of invoking tools directly */
     private eventDrivenMode;
+    /** Opt-in stream-layer prestart config for event-driven tools. */
+    private eagerEventToolExecution?;
+    /** Shared per-run prestarted tool registry populated by ChatModelStreamHandler. */
+    private eagerEventToolExecutions?;
+    /** Shared per-run per-tool turn counter used by eager and normal event dispatch. */
+    private eagerEventToolUsageCount?;
     /** Agent ID for event-driven mode */
     private agentId?;
     /** Tool names that bypass event dispatch and execute directly (e.g., graph-managed handoff tools) */
@@ -123,7 +129,7 @@ export declare class ToolNode<T = any> extends RunnableCallable<T, T> {
      * other's in-flight state.
      */
     private anonBatchCounter;
-    constructor({ tools, toolMap, name, tags, errorHandler, toolCallStepIds, handleToolErrors, loadRuntimeTools, toolRegistry, sessions, eventDrivenMode, agentId, directToolNames, maxContextTokens, maxToolResultChars, hookRegistry, humanInTheLoop, toolOutputReferences, toolOutputRegistry, toolExecution, fileCheckpointer, }: t.ToolNodeConstructorParams);
+    constructor({ tools, toolMap, name, tags, errorHandler, toolCallStepIds, handleToolErrors, loadRuntimeTools, toolRegistry, sessions, eventDrivenMode, eagerEventToolExecution, eagerEventToolExecutions, eagerEventToolUsageCount, agentId, directToolNames, maxContextTokens, maxToolResultChars, hookRegistry, humanInTheLoop, toolOutputReferences, toolOutputRegistry, toolExecution, fileCheckpointer, }: t.ToolNodeConstructorParams);
     /**
      * Returns the run-scoped tool output registry, or `undefined` when
      * the feature is disabled.
@@ -177,6 +183,8 @@ export declare class ToolNode<T = any> extends RunnableCallable<T, T> {
      * @returns A ReadonlyMap where keys are tool names and values are their usage counts.
      */
     getToolUsageCounts(): ReadonlyMap<string, number>;
+    private recordToolUsageTurn;
+    private recordEventToolPlanningTurn;
     /**
      * Runs a single tool call with error handling.
      *
@@ -309,6 +317,9 @@ export declare class ToolNode<T = any> extends RunnableCallable<T, T> {
      *    ToolMessages (appended AFTER to respect provider ordering).
      */
     private dispatchToolEvents;
+    private canConsumeEagerEventExecution;
+    private takeMatchingEagerEventExecution;
+    private resolveEagerEventExecution;
     /**
      * Fires the `PostToolBatch` hook (if registered) and appends the
      * accumulated batch-level `additionalContext` strings to `injected`

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

@@ -0,0 +1,23 @@
+import type * as t from '@/types';
+export declare function coerceRecordArgs(args: unknown): Record<string, unknown> | undefined;
+export declare function stableStringify(value: unknown): string;
+export declare function recordArgsEqual(left: Record<string, unknown>, right: Record<string, unknown>): boolean;
+export declare function normalizeError(error: unknown): Error;
+export type ToolExecutionPlanCall = {
+    id?: string;
+    name: string;
+    args: unknown;
+    stepId?: string;
+    codeSessionContext?: t.ToolCallRequest['codeSessionContext'];
+};
+export type ToolExecutionRequestPlan = {
+    allRequests: t.ToolCallRequest[];
+    requests: t.ToolCallRequest[];
+    rejectedResults: t.ToolExecuteResult[];
+};
+export declare function buildToolExecutionRequestPlan(args: {
+    toolCalls: ToolExecutionPlanCall[];
+    usageCount: Map<string, number>;
+    invalidArgsBehavior?: 'abort' | 'error-result';
+    recordTurn?: (toolName: string, turn: number, callId: string) => void;
+}): ToolExecutionRequestPlan | undefined;

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

@@ -0,0 +1,13 @@
+export declare const STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY = "lc_streamed_tool_call_adapter";
+export declare const STREAMED_TOOL_CALL_SEAL_METADATA_KEY = "lc_streamed_tool_call_seal";
+export declare const OPENAI_RESPONSES_STREAMED_TOOL_CALL_ADAPTER = "openai_responses";
+export type StreamedToolCallAdapter = typeof OPENAI_RESPONSES_STREAMED_TOOL_CALL_ADAPTER;
+export type StreamedToolCallSeal = {
+    kind: 'single';
+    id?: string;
+    index?: number;
+} | {
+    kind: 'all';
+};
+export declare function getStreamedToolCallAdapter(metadata: Record<string, unknown> | undefined): StreamedToolCallAdapter | undefined;
+export declare function getStreamedToolCallSeal(metadata: Record<string, unknown> | undefined): StreamedToolCallSeal | undefined;

package/dist/types/types/hitl.d.ts

@@ -296,6 +296,10 @@ export interface RunInterruptResult<TPayload = HumanInterruptPayload> {
     interruptId: string;
     /** `thread_id` the run was bound to — required to resume. */
     threadId?: string;
+    /** LangGraph checkpoint id that contains the paused interrupt task. */
+    checkpointId?: string;
+    /** LangGraph checkpoint namespace for the paused interrupt task. */
+    checkpointNs?: string;
     /** Structured payload describing what needs human input. */
     payload: TPayload;
 }

package/dist/types/types/run.d.ts

@@ -7,7 +7,7 @@ import type * as s from '@/types/stream';
 import type * as e from '@/common/enum';
 import type * as g from '@/types/graph';
 import type * as l from '@/types/llm';
-import type { ToolSessionMap, ToolExecutionConfig, ToolOutputReferencesConfig } from '@/types/tools';
+import type { ToolSessionMap, ToolExecutionConfig, ToolOutputReferencesConfig, EagerEventToolExecutionConfig } from '@/types/tools';
 import type { HumanInTheLoopConfig } from '@/types/hitl';
 import type { HookRegistry } from '@/hooks';
 export type ZodObjectAny = z.ZodObject<any, any, any, any>;
@@ -145,6 +145,16 @@ export type RunConfig = {
      * placeholders. Disabled by default so existing runs are unaffected.
      */
     toolOutputReferences?: ToolOutputReferencesConfig;
+    /**
+     * Opt-in latency optimization for event-driven tools. When enabled,
+     * the streaming layer may start a tool call as soon as it sees a
+     * complete, parseable tool call; ToolNode still waits for the final
+     * assistant message before appending ToolMessages, preserving provider
+     * ordering. The SDK automatically falls back to normal batch dispatch
+     * when hooks, HITL, output references, or ambiguous stream shapes make
+     * eager dispatch unsafe.
+     */
+    eagerEventToolExecution?: EagerEventToolExecutionConfig;
     /**
      * Selects the execution backend for built-in code tools. Omit this to keep
      * the remote LibreChat Code API sandbox. Set `{ engine: 'local' }` to run

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

@@ -22,6 +22,36 @@ export type ToolRefs = {
     toolMap?: ToolMap;
 };
 export type ToolRefGenerator = (tool_calls: ToolCall[]) => ToolRefs;
+export type EagerEventToolExecutionConfig = {
+    /**
+     * When enabled, event-driven tool calls may be started from the
+     * streaming layer as soon as the SDK observes a complete tool call.
+     * Results are still held until ToolNode materializes the final
+     * ToolMessages so provider message ordering is preserved.
+     */
+    enabled?: boolean;
+};
+export type EagerEventToolExecutionOutcome = {
+    results: ToolExecuteResult[];
+    error?: undefined;
+} | {
+    results?: undefined;
+    error: Error;
+};
+export type EagerEventToolExecution = {
+    toolCallId: string;
+    toolName: string;
+    args: Record<string, unknown>;
+    request: ToolCallRequest;
+    promise: Promise<EagerEventToolExecutionOutcome>;
+};
+export type EagerEventToolCallChunkState = {
+    id?: string;
+    name?: string;
+    argsText: string;
+    index?: number;
+    lastArgsFragment?: string;
+};
 export type ToolNodeOptions = {
     name?: string;
     tags?: string[];
@@ -41,6 +71,12 @@ export type ToolNodeOptions = {
     agentId?: string;
     /** Tool names that must be executed directly (via runTool) even in event-driven mode (e.g., graph-managed handoff tools) */
     directToolNames?: Set<string>;
+    /** Opt-in eager execution for event-driven tool calls. */
+    eagerEventToolExecution?: EagerEventToolExecutionConfig;
+    /** Shared per-run eager execution registry populated by the stream handler. */
+    eagerEventToolExecutions?: Map<string, EagerEventToolExecution>;
+    /** Shared per-run per-tool turn counter used by eager and normal event dispatch. */
+    eagerEventToolUsageCount?: Map<string, number>;
     /**
      * Hook registry for PreToolUse/PostToolUse/PostToolUseFailure/
      * PermissionDenied lifecycle hooks. Fires for **every** tool the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents",
-  "version": "3.1.86",
+  "version": "3.1.88",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/esm/main.mjs",
   "types": "./dist/types/index.d.ts",
@@ -10,6 +10,16 @@
       "require": "./dist/cjs/main.cjs",
       "types": "./dist/types/index.d.ts"
     },
+    "./openai": {
+      "import": "./dist/esm/openai/index.mjs",
+      "require": "./dist/cjs/openai/index.cjs",
+      "types": "./dist/types/openai/index.d.ts"
+    },
+    "./responses": {
+      "import": "./dist/esm/responses/index.mjs",
+      "require": "./dist/cjs/responses/index.cjs",
+      "types": "./dist/types/responses/index.d.ts"
+    },
     "./langchain": {
       "import": "./dist/esm/langchain/index.mjs",
       "require": "./dist/cjs/langchain/index.cjs",
@@ -68,6 +78,12 @@
       ],
       "langchain/*": [
         "dist/types/langchain/*"
+      ],
+      "openai": [
+        "dist/types/openai/index.d.ts"
+      ],
+      "responses": [
+        "dist/types/responses/index.d.ts"
       ]
     }
   },
@@ -133,6 +149,7 @@
     "local:image": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/local_engine_image.ts --provider 'anthropic' --name 'Jo' --location 'New York, NY'",
     "local:compile": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/local_engine_compile.ts --provider 'anthropic' --name 'Jo' --location 'New York, NY'",
     "compare:pi": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/compare_pi_vs_ours.ts",
+    "session:live": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/session_live.ts",
     "local:workspace": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/local_engine_workspace.ts --provider 'anthropic' --name 'Jo' --location 'New York, NY'",
     "programmatic_exec_agent": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/programmatic_exec_agent.ts --provider 'openAI' --name 'Jo' --location 'New York, NY'",
     "ant_web_search": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/ant_web_search.ts --name 'Jo' --location 'New York, NY'",
@@ -213,7 +230,7 @@
     "@langfuse/langchain": "^4.3.0",
     "@langfuse/otel": "^4.3.0",
     "@langfuse/tracing": "^4.3.0",
-    "@opentelemetry/sdk-node": "^0.207.0",
+    "@opentelemetry/sdk-node": "^0.218.0",
     "@scarf/scarf": "^1.4.0",
     "@types/diff": "^7.0.2",
     "ai-tokenizer": "^1.0.6",