@librechat/agents 3.5.0 → 3.6.0

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

@@ -18,7 +18,7 @@
  * must call {@link stripIntent} before using their args so no tool receives a
  * parameter it did not declare.
  */
-import type { JsonSchemaType, OutcomePatch } from '../types';
+import type { JsonSchemaType, OutcomePatch } from '@/types';
 /** Argument carrying the model-authored label for a tool call. */
 export declare const INTENT_ARG = "intent";
 /**

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

@@ -23,8 +23,8 @@
  * exit code is reported.
  */
 import type { DynamicStructuredTool } from '@langchain/core/tools';
-import type * as t from '../../types';
-import { Constants } from '../../common';
+import type * as t from '@/types';
+import { Constants } from '@/common';
 /** Back-compat alias; canonical name lives on `Constants.COMPILE_CHECK`. */
 export declare const CompileCheckToolName = Constants.COMPILE_CHECK;
 export declare function createCompileCheckTool(config?: t.LocalExecutionConfig): DynamicStructuredTool;

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

@@ -1,5 +1,5 @@
 import type { WorkspaceFS } from './workspaceFS';
-import type * as t from '../../types';
+import type * as t from '@/types';
 /**
  * Per-Run snapshot store for write_file / edit_file. Captures the
  * pre-write byte content of every path the local engine is about to

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

@@ -1,6 +1,6 @@
 import type { DynamicStructuredTool } from '@langchain/core/tools';
-import type * as t from '../../types';
-import { Constants } from '../../common';
+import type * as t from '@/types';
+import { Constants } from '@/common';
 /**
  * Tool name aliases retained for back-compat with consumers that imported
  * the per-file `Local*ToolName` constants. The canonical names live on

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

@@ -1,5 +1,5 @@
 import type { WorkspaceFS } from './workspaceFS';
-import type * as t from '../../types';
+import type * as t from '@/types';
 type SpawnResult = {
     stdout: string;
     stderr: string;

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

@@ -1,5 +1,5 @@
 import type { DynamicStructuredTool } from '@langchain/core/tools';
-import type * as t from '../../types';
+import type * as t from '@/types';
 export declare const LocalCodeExecutionToolDescription: string;
 export declare const LocalBashExecutionToolDescription: string;
 export declare function createLocalCodeExecutionTool(config?: t.LocalExecutionConfig): DynamicStructuredTool;

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

@@ -1,5 +1,5 @@
 import type { DynamicStructuredTool } from '@langchain/core/tools';
-import type * as t from '../../types';
+import type * as t from '@/types';
 /**
  * Run the host's `PreToolUse` hook chain for a single bridge call.
  * Returns the (possibly rewritten) input and a `denyReason` if any

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

@@ -1,4 +1,4 @@
-import type * as t from '../../types';
+import type * as t from '@/types';
 export type BashAstFinding = {
     code: string;
     message: string;

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

@@ -1,4 +1,4 @@
-import type * as t from '../../types';
+import type * as t from '@/types';
 type ResolveLocalToolsResult = {
     toolMap: t.ToolMap;
     directToolNames: Set<string>;

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

@@ -15,7 +15,7 @@
  * is slow and per-file syntax (without type info) misses most TS
  * errors anyway. Use the project-level `compile_check` tool for that.
  */
-import type * as t from '../../types';
+import type * as t from '@/types';
 export type SyntaxCheckOutcome = {
     ok: true;
 } | {

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

@@ -1,4 +1,4 @@
-import type { JsonSchemaType } from '../types';
+import type { JsonSchemaType } from '@/types';
 export declare const DEFAULT_CODE_API_RUN_TIMEOUT_MS = 15000;
 export declare const MIN_CODE_API_RUN_TIMEOUT_MS = 1000;
 export declare const MAX_CODE_API_RUN_TIMEOUT_SCHEMA_MS = 300000;

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

@@ -0,0 +1,5 @@
+import type { RunStepResumeState } from '@/types';
+export declare function isRunStepResumeState(value: unknown): value is RunStepResumeState;
+export declare function attachRunStepResumeState(payload: unknown, state: RunStepResumeState): object;
+export declare function getRunStepResumeState(payload: unknown): RunStepResumeState | undefined;
+export declare function stripRunStepResumeState(payload: unknown): unknown;

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

@@ -1,5 +1,5 @@
 import { type StructuredToolInterface } from '@langchain/core/tools';
-import type { LCTool } from '../types';
+import type { LCTool } from '@/types';
 /**
  * Creates a schema-only tool for LLM binding in event-driven mode.
  * These tools have valid schemas for the LLM to understand but should

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

@@ -1,4 +1,4 @@
-import type { AnthropicTextBlockParam, AnthropicWebSearchResultBlockParam } from '../../llm/anthropic/types';
+import type { AnthropicTextBlockParam, AnthropicWebSearchResultBlockParam } from '@/llm/anthropic/types';
 import type { SearchResultData } from './types';
 /**
  * Coerces Anthropic web search results to the SearchResultData format

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

@@ -1,4 +1,4 @@
-import type { SkillCatalogEntry } from '../types';
+import type { SkillCatalogEntry } from '@/types';
 export type SkillCatalogOptions = {
     /** Total context window in tokens. Default: 200_000 */
     contextWindowTokens?: number;

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

@@ -1,12 +1,12 @@
 import { BaseMessage } from '@langchain/core/messages';
 import type { RunnableConfig } from '@langchain/core/runnables';
 import type { ToolCall } from '@langchain/core/messages/tool';
-import type { MultiAgentGraphState, HumanInTheLoopConfig, StandardGraphInput, ExecutableSubagentConfigEntry, SubagentExecutionContext, SubagentUsageSink, TokenCounter } from '../../types';
+import type { MultiAgentGraphState, HumanInTheLoopConfig, StandardGraphInput, ExecutableSubagentConfigEntry, SubagentExecutionContext, SubagentUsageSink, TokenCounter } from '@/types';
 import type { SubagentResumeManifest, SettledSubagentToolOutput } from './SubagentReplay';
-import type { HookRegistry } from '../../hooks';
-import type { GraphFactory } from '../../graphs/graphFactory';
-import type { StandardGraph } from '../../graphs/Graph';
-import type { HandlerRegistry } from '../../events';
+import type { HookRegistry } from '@/hooks';
+import type { GraphFactory } from '@/graphs/graphFactory';
+import type { StandardGraph } from '@/graphs/Graph';
+import type { HandlerRegistry } from '@/events';
 export { buildChildInputs, isGraphSubagentConfig, normalizeSubagentConfigs, normalizeSubagentConfigEntries, resolveSubagentConfigs, resolveSubagentConfigEntries, } from './childGraphConfig';
 export declare const DEFAULT_SUBAGENT_DESCRIPTION = "No task description provided";
 export type SubagentExecuteParams = {
@@ -207,6 +207,31 @@ export declare class SubagentExecutor {
     resetCheckpointThreadIds(): void;
     private getGraphChildCheckpointThreadIds;
     private clearChildGraph;
+    /**
+     * Terminal sweep for a child graph's run steps. `Run.processStream` sweeps
+     * only the graph it owns, and a child executes through `workflow.invoke()`
+     * outside that loop — so without this, a child's last message step (no
+     * successor step ever opens to close it) and every step of an aborted child
+     * stay `in_progress` forever, leaving hosts with unmatched starts.
+     *
+     * Must run BEFORE `forwarding.drain()`: closures reach the parent only as
+     * child custom events through the forwarder, which stops relaying once
+     * drained.
+     *
+     * Deliberately not called on the interrupt path, mirroring the parent's
+     * `isAwaitingResume` guard: an in-process resume continues into these same
+     * steps, so closing them would strand the resumed run. A resume that
+     * crosses a process boundary is a known gap either way — the child rebuilds
+     * from `SubagentGraphResumeState`, which carries tool-call identity but not
+     * `contentData`, so pre-interrupt steps are unreachable from the new graph
+     * and stay open. That is the child-level instance of the same cross-process
+     * orphan the parent graph has, and it needs persisted lifecycle state to
+     * fix rather than a sweep here.
+     *
+     * `at` is the moment execution actually ended, threaded through so
+     * observational work between then and the sweep cannot inflate the stamps.
+     */
+    private closeChildRunSteps;
     clearHeavyState(): void;
     private getResumeCheckpointMarker;
     getSettledToolOutput(call: ToolCall, config: RunnableConfig): Promise<SettledSubagentToolOutput | undefined>;

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

@@ -1,8 +1,8 @@
 import type { ToolCall, ToolMessage } from '@langchain/core/messages/tool';
 import type { RunnableConfig } from '@langchain/core/runnables';
-import type { ToolOutputReferenceState } from '../../tools/toolOutputReferences';
-import type { ToolApprovalReplaySnapshot } from '../../hooks';
-import type { ToolSessionContext } from '../../types';
+import type { ToolOutputReferenceState } from '@/tools/toolOutputReferences';
+import type { ToolApprovalReplaySnapshot } from '@/hooks';
+import type { RunStepResumeState, ToolSessionContext } from '@/types';
 export declare const SUBAGENT_RESUME_MANIFEST_CONFIG_KEY = "__librechat_subagent_resume_manifest";
 export declare const SUBAGENT_RESUME_ATTEMPT_CONFIG_KEY = "__librechat_subagent_resume_attempt";
 export declare const SUBAGENT_PARENT_BATCH_CONFIG_KEY = "__librechat_subagent_parent_batch";
@@ -43,6 +43,7 @@ export interface SubagentGraphResumeState {
     toolNodes: SubagentToolNodeResumeState[];
     eagerToolUsage: SubagentEagerToolUsageState[];
     eagerToolSuppressions: string[];
+    runStepState?: RunStepResumeState;
     toolOutputReferences?: ToolOutputReferenceState;
 }
 /** Private checkpoint payload linking a parent pause to an exact child state. */

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

@@ -1,5 +1,5 @@
-import type { AgentInputs, ExecutableSubagentConfig, ExecutableSubagentConfigEntry, GraphEdge, GraphSubagentConfig, ResolvedSubagentConfig, ResolvedSubagentConfigEntry, SubagentConfig, SubagentConfigEntry } from '../../types';
-import type { AgentContext } from '../../agents/AgentContext';
+import type { AgentInputs, ExecutableSubagentConfig, ExecutableSubagentConfigEntry, GraphEdge, GraphSubagentConfig, ResolvedSubagentConfig, ResolvedSubagentConfigEntry, SubagentConfig, SubagentConfigEntry } from '@/types';
+import type { AgentContext } from '@/agents/AgentContext';
 type ChildGraphPlanBase = {
     subjectAgentId: string;
     checkpointNodeId: string;

package/dist/types/types/activityLabel.d.ts

@@ -1,7 +1,7 @@
 import type { RunnableConfig } from '@langchain/core/runnables';
-import type { AssistantTextPhase } from '../types/assistantPhase';
-import type { ClientOptions } from '../types/llm';
-import type { Providers } from '../common';
+import type { AssistantTextPhase } from '@/types/assistantPhase';
+import type { ClientOptions } from '@/types/llm';
+import type { Providers } from '@/common';
 /** One tool call's contribution to the label payload (host-assembled). */
 export type ActivityLabelToolEntry = {
     toolName: string;

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

@@ -4,13 +4,13 @@ import type { START, StateGraph, StateGraphArgs } from '@langchain/langgraph';
 import type { RunnableConfig, Runnable } from '@langchain/core/runnables';
 import type { ChatGenerationChunk } from '@langchain/core/outputs';
 import type { GoogleAIToolType } from '@langchain/google-common';
-import type { SummarizationNodeInput, SummarizeCompleteEvent, SummarizationConfig, SummarizeStartEvent, SummarizeDeltaEvent } from '../types/summarize';
-import type { RunStep, RunStepDeltaEvent, RunStepClosedEvent, MessageDeltaEvent, ReasoningDeltaEvent } from '../types/stream';
-import type { ToolMap, ToolSessionMap, ToolEndEvent, GenericTool, LCTool, ToolExecuteBatchRequest } from '../types/tools';
-import type { TokenCounter, StreamLimits, StreamPreemption, TokenBudgetBreakdown } from '../types/run';
-import type { Providers, Callback, GraphNodeKeys } from '../common';
-import type { StandardGraph, MultiAgentGraph } from '../graphs';
-import type { ClientOptions } from '../types/llm';
+import type { SummarizationNodeInput, SummarizeCompleteEvent, SummarizationConfig, SummarizeStartEvent, SummarizeDeltaEvent } from '@/types/summarize';
+import type { RunStep, RunStepDeltaEvent, RunStepResumeState, RunStepClosedEvent, MessageDeltaEvent, ReasoningDeltaEvent } from '@/types/stream';
+import type { ToolMap, ToolSessionMap, ToolEndEvent, GenericTool, LCTool, ToolExecuteBatchRequest } from '@/types/tools';
+import type { TokenCounter, StreamLimits, StreamPreemption, TokenBudgetBreakdown } from '@/types/run';
+import type { Providers, Callback, GraphNodeKeys } from '@/common';
+import type { StandardGraph, MultiAgentGraph } from '@/graphs';
+import type { ClientOptions } from '@/types/llm';
 /** Interface for bound model with stream and invoke methods */
 export interface ChatModel {
     stream?: (messages: BaseMessage[], config?: RunnableConfig) => Promise<AsyncIterable<AIMessageChunk>>;
@@ -28,6 +28,7 @@ export type SystemCallbacks = {
 };
 export type BaseGraphState = {
     messages: BaseMessage[];
+    runStepState?: RunStepResumeState;
 };
 export type AgentSubgraphState = BaseGraphState & {
     summarizationRequest?: SummarizationNodeInput;
@@ -628,6 +629,14 @@ export interface LangfuseConfig {
 }
 export interface AgentInputs {
     agentId: string;
+    /**
+     * Partition key for transient code-session ids and file refs. Agents with
+     * the same key share those refs; different execution profiles/scopes must
+     * use different keys. Defaults to the legacy shared `execute_code` slot.
+     * Non-default partitions also disable speculative eager execution of code
+     * tools because their factory may target a durable backend.
+     */
+    codeSessionKey?: string;
     /** Human-readable name for the agent (used in handoff context). Defaults to agentId if not provided. */
     name?: string;
     toolEnd?: boolean;

package/dist/types/types/llm.d.ts

@@ -12,15 +12,15 @@ import type { AnthropicInput } from '@langchain/anthropic';
 import type { Runnable } from '@langchain/core/runnables';
 import type { OpenAI as OpenAIClient } from 'openai';
 import type { ChatXAIInput } from '@langchain/xai';
-import type { ChatOpenRouterCallOptions } from '../llm/openrouter';
-import type { PromptCacheTtl } from '../messages/cache';
-import { AzureChatOpenAI, ChatDeepSeek, ChatMoonshot, ChatOpenAI, ChatXAI } from '../llm/openai';
-import { CustomChatGoogleGenerativeAI } from '../llm/google';
-import { CustomChatBedrockConverse } from '../llm/bedrock';
-import { CustomAnthropic } from '../llm/anthropic';
-import { ChatOpenRouter } from '../llm/openrouter';
-import { ChatVertexAI } from '../llm/vertexai';
-import { Providers } from '../common';
+import type { ChatOpenRouterCallOptions } from '@/llm/openrouter';
+import type { PromptCacheTtl } from '@/messages/cache';
+import { AzureChatOpenAI, ChatDeepSeek, ChatMoonshot, ChatOpenAI, ChatXAI } from '@/llm/openai';
+import { CustomChatGoogleGenerativeAI } from '@/llm/google';
+import { CustomChatBedrockConverse } from '@/llm/bedrock';
+import { CustomAnthropic } from '@/llm/anthropic';
+import { ChatOpenRouter } from '@/llm/openrouter';
+import { ChatVertexAI } from '@/llm/vertexai';
+import { Providers } from '@/common';
 export type AzureClientOptions = Partial<OpenAIChatInput> & Partial<AzureOpenAIInput> & {
     openAIApiKey?: string;
     openAIApiVersion?: string;

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

@@ -3,13 +3,13 @@ import type { RunnableConfig } from '@langchain/core/runnables';
 import type { BaseMessage } from '@langchain/core/messages';
 import type { StructuredTool } from '@langchain/core/tools';
 import type * as z from 'zod';
-import type { ToolSessionMap, ToolExecutionConfig, ToolOutputReferencesConfig, EagerEventToolExecutionConfig } from '../types/tools';
-import type { HumanInTheLoopConfig } from '../types/hitl';
-import type { HookRegistry } from '../hooks';
-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, EagerEventToolExecutionConfig } from '@/types/tools';
+import type { HumanInTheLoopConfig } from '@/types/hitl';
+import type { HookRegistry } from '@/hooks';
+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';
 export type ZodObjectAny = z.ZodObject<any, any, any, any>;
 export type BaseGraphConfig = {
     llmConfig: l.LLMConfig;

package/dist/types/types/stream.d.ts

@@ -3,11 +3,11 @@ 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 Anthropic from '@anthropic-ai/sdk';
-import type { AnthropicContentBlock } from '../llm/anthropic/types';
-import type { AssistantTextPhase } from '../types/assistantPhase';
-import type { SummarizeCompleteEvent } from '../types/summarize';
-import type { ToolEndEvent } from '../types/tools';
-import { StepTypes, ContentTypes, GraphEvents } from '../common/enum';
+import type { AnthropicContentBlock } from '@/llm/anthropic/types';
+import type { AssistantTextPhase } from '@/types/assistantPhase';
+import type { SummarizeCompleteEvent } from '@/types/summarize';
+import type { ToolEndEvent } from '@/types/tools';
+import { StepTypes, ContentTypes, GraphEvents } from '@/common/enum';
 export type HandleLLMEnd = (output: LLMResult, runId: string, parentRunId?: string, tags?: string[]) => void;
 export type MetadataAggregatorResult = {
     handleLLMEnd: HandleLLMEnd;
@@ -75,6 +75,24 @@ export type RunStep = {
     summary?: SummaryContentBlock;
     usage?: null | object;
 };
+/** Minimal durable lifecycle state needed to continue open run steps. */
+export interface RunStepResumeEntry {
+    step: RunStep;
+    pendingToolCallIds: string[];
+    latestCompletionAt?: number;
+    openMessageStep: boolean;
+}
+/** SDK-private state persisted in LangGraph checkpoints for process-safe resume. */
+export interface RunStepResumeState {
+    version: 1;
+    revision: number;
+    nextIndex: number;
+    toolCallSteps: Array<{
+        toolCallId: string;
+        stepId: string;
+    }>;
+    steps: RunStepResumeEntry[];
+}
 /**
  * Represents a run step delta i.e. any changed fields on a run step during
  * streaming.

package/dist/types/types/summarize.d.ts

@@ -1,5 +1,5 @@
-import type { SummaryContentBlock } from '../types/stream';
-import type { Providers } from '../common';
+import type { SummaryContentBlock } from '@/types/stream';
+import type { Providers } from '@/common';
 export type SummarizationTrigger = {
     type: 'token_ratio' | 'remaining_tokens' | 'messages_to_refine' | (string & {});
     value: number;

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

@@ -1,12 +1,12 @@
 import type { StructuredToolInterface } from '@langchain/core/tools';
-import type { RunnableToolLike } from '@langchain/core/runnables';
+import type { RunnableConfig, RunnableToolLike } from '@langchain/core/runnables';
 import type { ToolCall } from '@langchain/core/messages/tool';
-import type { ToolOutputReferenceRegistry } from '../tools/toolOutputReferences';
-import type { RunBreakerScope } from '../llm/streamLimits';
-import type { MessageContentComplex, ToolErrorData } from './stream';
+import type { ToolOutputReferenceRegistry } from '@/tools/toolOutputReferences';
+import type { RunBreakerScope } from '@/llm/streamLimits';
+import type { MessageContentComplex, RunStepResumeState, ToolErrorData } from './stream';
 import type { HumanInTheLoopConfig } from './hitl';
 import type { LangfuseConfig } from './graph';
-import type { HookRegistry } from '../hooks';
+import type { HookRegistry } from '@/hooks';
 /** Replacement type for `import type { ToolCall } from '@langchain/core/messages/tool'` in order to have stringified args typed */
 export type CustomToolCall = {
     name: string;
@@ -118,6 +118,8 @@ export type ToolNodeOptions = {
     toolRegistry?: LCToolRegistry;
     /** Reference to Graph's sessions map for automatic session injection */
     sessions?: ToolSessionMap;
+    /** Partition within `sessions` used by this agent's code tools. */
+    codeSessionKey?: string;
     /** When true, dispatches ON_TOOL_EXECUTE events instead of invoking tools directly */
     eventDrivenMode?: boolean;
     /** Tool definitions for event-driven mode (used for context, not invocation) */
@@ -264,6 +266,10 @@ export type ToolNodeOptions = {
      * controller.
      */
     getRunScope?: () => RunBreakerScope;
+    /** SDK-owned checkpoint bridge for open run-step lifecycle state. */
+    restoreRunStepResumeState?: (state?: RunStepResumeState, config?: RunnableConfig) => void;
+    /** SDK-owned checkpoint snapshot for open run-step lifecycle state. */
+    createRunStepResumeState?: () => RunStepResumeState;
 };
 export type ToolNodeConstructorParams = ToolRefs & ToolNodeOptions;
 export type ToolEndEvent = {
@@ -361,6 +367,19 @@ export type CodeEnvFile = (CodeEnvFileBase & {
     kind: 'user';
 });
 export type CodeExecutionToolParams = undefined | {
+    /** Trusted Code API endpoint selected by the host for this agent. */
+    baseUrl?: string;
+    /**
+     * Expected Code API execution profile. Sent as a request assertion so
+     * endpoint/configuration drift fails closed instead of silently using
+     * the wrong sandbox backend.
+     */
+    executionProfile?: CodeApiExecutionProfile;
+    /**
+     * Trusted warm-runtime affinity hint selected by the host for this
+     * agent invocation. This overrides the legacy ToolNode-injected hint.
+     */
+    runtimeSessionHint?: string;
     /** Execution session — see `CodeSessionContext.session_id`. */
     session_id?: string;
     user_id?: string;
@@ -368,15 +387,14 @@ export type CodeExecutionToolParams = undefined | {
     /** 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.
+     * Advertise filesystem-tier stateful sessions in the tool description
+     * and allow a trusted runtime affinity hint onto the wire. Resolve this,
+     * `baseUrl`, `executionProfile`, and `runtimeSessionHint` together from
+     * the executing agent so the prompt and backend agree.
      */
     statefulSessions?: boolean;
 };
+export type CodeApiExecutionProfile = 'default' | 'stateful';
 export type CodeApiAuthHeaderMap = Record<string, string>;
 export type CodeApiAuthHeaders = CodeApiAuthHeaderMap | (() => CodeApiAuthHeaderMap | Promise<CodeApiAuthHeaderMap>);
 export type FileRef = {
@@ -756,7 +774,7 @@ export type LocalExecConfig = {
      * `spawn` — see the type-level note above on why both should be
      * overridden together for non-host engines.
      */
-    fs?: import('../tools/local/workspaceFS').WorkspaceFS;
+    fs?: import('@/tools/local/workspaceFS').WorkspaceFS;
     /**
      * Set by custom execution backends that already provide their own
      * sandbox boundary. Suppresses the local host-sandbox warning while
@@ -1032,19 +1050,17 @@ export type CloudflareSandboxExecutionConfig = {
 };
 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.
+     * Legacy run-scoped opt-in for warm runtime hint injection. New hosts that
+     * need mixed execution profiles should resolve `statefulSessions`,
+     * `baseUrl`, `executionProfile`, and `runtimeSessionHint` on each executing
+     * agent's tool factories instead. Direct executors ignore this injected hint
+     * unless their own factory has `statefulSessions: true`.
      *
      * 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).
+     * factory param.
      */
     statefulSessions?: boolean;
     /**
@@ -1078,7 +1094,7 @@ export type ProgrammaticCache = {
     hookContext?: ProgrammaticHookContext;
 };
 export type ProgrammaticHookContext = {
-    registry: import('../hooks').HookRegistry | undefined;
+    registry: import('@/hooks').HookRegistry | undefined;
     runId: string;
     threadId?: string;
     agentId?: string;
@@ -1193,6 +1209,10 @@ export type BashProgrammaticToolCallingParams = ProgrammaticToolCallingParams;
 export type ProgrammaticToolCallingParams = {
     /** Code API base URL (or use CODE_BASEURL env var) */
     baseUrl?: string;
+    /** Expected Code API execution profile (host-controlled). */
+    executionProfile?: CodeApiExecutionProfile;
+    /** Trusted warm-runtime affinity hint for this agent invocation. */
+    runtimeSessionHint?: string;
     /** Safety limit for round-trips (default: 20) */
     maxRoundTrips?: number;
     /** Maximum per-sandbox-run timeout for PTC's legacy `timeout` field. */

package/dist/types/utils/errors.d.ts

@@ -1,4 +1,4 @@
-import type { Providers } from '../common';
+import type { Providers } from '@/common';
 /**
  * Why the request was rejected. Both kinds are fixed by shrinking the
  * prompt, which is what makes them recoverable; they are distinguished

package/dist/types/utils/events.d.ts

@@ -1,5 +1,5 @@
 import type { RunnableConfig } from '@langchain/core/runnables';
-import type { AgentLogEvent } from '../types/graph';
+import type { AgentLogEvent } from '@/types/graph';
 /**
  * Safely dispatches a custom event and properly awaits it to avoid
  * race conditions where events are dispatched after run cleanup.

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

@@ -14,9 +14,9 @@
  * });
  * ```
  */
-import type * as t from '../types';
-import { createContentAggregator } from '../stream';
-import { GraphEvents } from '../common';
+import type * as t from '@/types';
+import { createContentAggregator } from '@/stream';
+import { GraphEvents } from '@/common';
 interface HandlerCallbacks {
     onRunStep?: (event: GraphEvents.ON_RUN_STEP, data: t.StreamEventData) => void;
     onRunStepCompleted?: (event: GraphEvents.ON_RUN_STEP_COMPLETED, data: t.StreamEventData) => void;

package/dist/types/utils/llm.d.ts

@@ -1,4 +1,4 @@
-import { Providers } from '../common';
+import { Providers } from '@/common';
 export declare function isOpenAILike(provider?: string | Providers): boolean;
 export declare function isGoogleLike(provider?: string | Providers): boolean;
 /** Returns true for native Anthropic or Bedrock running a Claude model. */

package/dist/types/utils/llmConfig.d.ts

@@ -1,3 +1,3 @@
-import type * as t from '../types';
+import type * as t from '@/types';
 export declare const llmConfigs: Record<string, t.LLMConfig | undefined>;
 export declare function getLLMConfig(provider: string): t.LLMConfig;

package/dist/types/utils/title.d.ts

@@ -1,4 +1,4 @@
 import type { Runnable } from '@langchain/core/runnables';
-import type * as t from '../types';
+import type * as t from '@/types';
 export declare const createTitleRunnable: (model: t.ChatModelInstance, _titlePrompt?: string) => Promise<Runnable>;
 export declare const createCompletionTitleRunnable: (model: t.ChatModelInstance, titlePrompt?: string) => Promise<Runnable>;

package/dist/types/utils/toolSessions.d.ts

@@ -0,0 +1,18 @@
+import type * as t from '@/types';
+type CodeSessionAgent = Pick<t.AgentInputs, 'codeSessionKey' | 'initialSessions'>;
+/**
+ * Seeds a top-level graph while preserving the legacy run-wide session map.
+ * A legacy `execute_code` seed is copied into every custom agent partition
+ * unless the host already supplied an explicit seed for that partition.
+ */
+export declare function seedRunInitialSessions(args: {
+    sessions: t.ToolSessionMap;
+    initialSessions: t.ToolSessionMap;
+    agents: Iterable<Pick<t.AgentInputs, 'codeSessionKey'>>;
+}): void;
+/**
+ * Seeds an isolated child graph from each selected agent. Legacy code-session
+ * entries are remapped to the owning agent's partition before they are merged.
+ */
+export declare function seedAgentInitialSessions(sessions: t.ToolSessionMap, agents: Iterable<CodeSessionAgent>): void;
+export {};