@librechat/agents 3.1.75 → 3.1.77-dev.1

package/dist/types/graphs/Graph.d.ts

@@ -46,6 +46,13 @@ export declare abstract class Graph<T extends t.BaseGraphState = t.BaseGraphStat
     invokedToolIds?: Set<string>;
     handlerRegistry: HandlerRegistry | undefined;
     hookRegistry: HookRegistry | undefined;
+    /**
+     * Run-scoped HITL configuration. When `humanInTheLoop?.enabled` is
+     * `true`, `ToolNode` raises a real `interrupt()` for `PreToolUse`
+     * `ask` decisions instead of treating them as a synchronous deny.
+     * Threaded from `RunConfig.humanInTheLoop`.
+     */
+    humanInTheLoop: t.HumanInTheLoopConfig | undefined;
     /**
      * Run-scoped config for the tool output reference registry. Threaded
      * from `RunConfig.toolOutputReferences` down into every ToolNode this

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

@@ -0,0 +1,55 @@
+/**
+ * Typed convenience wrapper around LangGraph's `interrupt()` for the
+ * `ask_user_question` interrupt category. Lets a custom graph node
+ * (or a tool implementation) suspend execution to collect a free-form
+ * answer from the human, without the host having to assemble the
+ * interrupt payload by hand. The companion to `Run.resume(answer)` on
+ * the host side.
+ *
+ * AsyncLocalStorage anchoring: this helper does NOT call
+ * `runWithConfig` itself — it expects to be invoked from inside a
+ * LangGraph node where the framework has already established the
+ * runnable config. ToolNode is the one place in this codebase that
+ * needs the manual `runWithConfig` shim, because its
+ * `RunnableCallable.trace = false` skips the upstream tracing path
+ * that normally sets up the AsyncLocalStorage frame; ordinary user
+ * nodes (RunnableLambda, addNode callbacks) do not have that
+ * constraint.
+ */
+import type { AskUserQuestionRequest, AskUserQuestionResolution } from '@/types/hitl';
+/**
+ * Suspend the current graph node to ask the human a question. Returns
+ * the host-supplied resolution after `Run.resume(resolution)` is
+ * called against a Run rebuilt with the same `thread_id` and
+ * checkpointer.
+ *
+ * On the FIRST call (no resume value available), `interrupt()` throws
+ * a `GraphInterrupt` that LangGraph catches; this function does not
+ * return — execution unwinds, the SDK persists the checkpoint, and
+ * the run completes with `run.getInterrupt()` returning a
+ * `RunInterruptResult` whose `payload` is an
+ * `AskUserQuestionInterruptPayload`.
+ *
+ * On RESUME, LangGraph re-runs the node from the start and this call
+ * returns the host's `AskUserQuestionResolution` directly.
+ *
+ * Hosts that prefer the raw `interrupt()` (e.g., to attach extra
+ * metadata) can construct an `AskUserQuestionInterruptPayload` and
+ * call `interrupt()` themselves — this helper is purely convenience.
+ *
+ * @example
+ * ```ts
+ * const builder = new StateGraph(MessagesAnnotation)
+ *   .addNode('clarifier', () => {
+ *     const { answer } = askUserQuestion({
+ *       question: 'Which environment should I deploy to?',
+ *       options: [
+ *         { label: 'Staging', value: 'staging' },
+ *         { label: 'Production', value: 'production' },
+ *       ],
+ *     });
+ *     return { messages: [new HumanMessage(`Use ${answer}`)] };
+ *   });
+ * ```
+ */
+export declare function askUserQuestion(question: AskUserQuestionRequest): AskUserQuestionResolution;

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

@@ -0,0 +1,6 @@
+/**
+ * Human-in-the-loop helpers. Type definitions live in `@/types/hitl`
+ * and re-export from the top-level types barrel; runtime helpers (like
+ * `askUserQuestion()`) live here.
+ */
+export { askUserQuestion } from './askUserQuestion';

package/dist/types/hooks/HookRegistry.d.ts

@@ -1,4 +1,17 @@
 import type { HookEvent, HookMatcher } from './types';
+/**
+ * Snapshot of a halt request raised by a hook returning
+ * `preventContinuation: true`. The SDK's run loop polls for this between
+ * stream events and exits cleanly when set, skipping the `Stop` hook
+ * (the run is being halted, not naturally completing). One per registry
+ * instance — the first hook to halt wins; subsequent halts are ignored
+ * so the original reason isn't clobbered.
+ */
+export interface HookHaltSignal {
+    reason: string;
+    /** Event of the hook that triggered the halt (for diagnostics). */
+    source: HookEvent;
+}
 /**
  * Run-scoped storage for hook matchers with an additional layer for
  * session-scoped matchers that should be cleaned up between sessions.
@@ -20,6 +33,18 @@ import type { HookEvent, HookMatcher } from './types';
 export declare class HookRegistry {
     private readonly global;
     private readonly sessions;
+    /**
+     * Per-session halt signals. Scoped by `sessionId` (= the run id the
+     * hook fired under) so a host that shares one registry across
+     * concurrent runs cannot leak `preventContinuation` from one run
+     * into another. Without scoping, a halt raised by run A's hook
+     * would trip run B's stream-loop poll on the next iteration —
+     * silently terminating an unrelated run.
+     *
+     * Map storage mirrors the reasoning above for session matchers:
+     * O(1) insertion in hot paths, no spread-on-write.
+     */
+    private readonly haltSignals;
     /**
      * Register a matcher for the lifetime of this registry (= one Run).
      * Returns an unregister function that removes the matcher by reference.
@@ -50,6 +75,39 @@ export declare class HookRegistry {
      * cannot leak into the next session on the same registry.
      */
     clearSession(sessionId: string): void;
+    /**
+     * Raise a halt signal scoped to `sessionId` (= the run id the hook
+     * fired under). The SDK's run loop polls for this between stream
+     * events with the run's own id. First-write-wins per session: a
+     * halt already raised by an earlier hook in the same run is
+     * preserved so the original `reason` / `source` aren't overwritten.
+     *
+     * Per-session scoping is critical when hosts share one registry
+     * across concurrent runs (e.g. a global policy registered once and
+     * reused). Without it, a `preventContinuation` from run A would
+     * trip run B's stream-loop poll on the next iteration and silently
+     * terminate an unrelated run.
+     *
+     * Called by the SDK after `executeHooks` returns an aggregate with
+     * `preventContinuation: true`. Hosts can also call it directly from
+     * inside a hook callback if they want to halt without going through
+     * the aggregated return value, but `preventContinuation` is the
+     * canonical path.
+     */
+    haltRun(sessionId: string, reason: string, source: HookEvent): void;
+    /**
+     * Returns the halt signal raised by hooks running under `sessionId`,
+     * or `undefined` if no hook in that run has halted. Polled by
+     * `Run.processStream` between stream events using the run's own id.
+     */
+    getHaltSignal(sessionId: string): HookHaltSignal | undefined;
+    /**
+     * Clears the halt signal for `sessionId`. Called by
+     * `Run.processStream` in its `finally` block so a subsequent
+     * invocation of the same Run (e.g. resume) starts with a fresh
+     * halt state. No-op when no signal exists for that session.
+     */
+    clearHaltSignal(sessionId: string): void;
     /** True if at least one matcher exists for `event` (global + session). */
     hasHookFor(event: HookEvent, sessionId?: string): boolean;
     private ensureSessionBucket;

package/dist/types/hooks/createToolPolicyHook.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Declarative `PreToolUse` hook factory. Lets hosts express common
+ * permission policies (allow / deny / ask lists + a global mode) without
+ * hand-rolling matching, precedence, and decision logic per-host.
+ *
+ * Maps directly to the Claude Code Agent SDK permission vocabulary
+ * (`allowed_tools` / `disallowed_tools` / `permissionMode`) so users of
+ * either SDK can think in the same terms. See the README's HITL section
+ * for the cross-walk and `docs/hooks-design-report.md` for the broader
+ * hook system context.
+ */
+import type { HookCallback } from './types';
+/**
+ * Permission mode controlling how tool calls that match no rule are
+ * resolved. Mirrors Claude Code's `permissionMode`.
+ *
+ *   - `default`  — unmatched tools fall through to `'ask'` (interrupt).
+ *   - `dontAsk`  — unmatched tools are denied; the human is never
+ *                  prompted. Useful for headless / API agents where a
+ *                  silent denial is preferable to a hung interrupt.
+ *   - `bypass`   — every tool is approved, except those matching `deny`
+ *                  patterns. The kill switch you flip when you trust
+ *                  the agent and want to stop being asked. Equivalent to
+ *                  Claude Code's `bypassPermissions`.
+ */
+export type ToolPolicyMode = 'default' | 'dontAsk' | 'bypass';
+export interface ToolPolicyConfig {
+    /**
+     * Global mode applied to tools that don't match any rule.
+     * Defaults to `'default'` (ask the human).
+     */
+    mode?: ToolPolicyMode;
+    /**
+     * Tool name patterns that are auto-approved without a prompt.
+     * Patterns support glob `*` wildcards: `read_file`, `mcp:github:*`,
+     * `*search*`. Match is anchored (`^pattern$`).
+     */
+    allow?: readonly string[];
+    /**
+     * Tool name patterns that are blocked outright. Wins over `allow`
+     * and `ask`, and overrides `mode: 'bypass'` — a deny rule always
+     * holds, matching Claude Code's "deny rules are checked first" guarantee.
+     */
+    deny?: readonly string[];
+    /**
+     * Tool name patterns that always trigger human approval, regardless
+     * of `mode: 'default'` vs `'dontAsk'`. In `mode: 'bypass'` these are
+     * still bypassed (because that's what bypass means).
+     */
+    ask?: readonly string[];
+    /**
+     * Optional reason attached to the resulting `ask` / `deny` hook
+     * decision so the host UI can render why approval is required.
+     * The literal token `{tool}` is replaced with the tool name.
+     */
+    reason?: string;
+}
+/**
+ * Build a `PreToolUse` hook callback that applies a declarative tool
+ * permission policy. Register it with a `HookRegistry` and the SDK's
+ * `humanInTheLoop` machinery handles the rest:
+ *
+ * ```ts
+ * const policyHook = createToolPolicyHook({
+ *   mode: 'default',
+ *   allow: ['read_*', 'grep', 'glob'],
+ *   deny:  ['delete_*'],
+ *   ask:   ['execute_*', 'mcp:*'],
+ * });
+ * registry.register('PreToolUse', { hooks: [policyHook] });
+ * ```
+ *
+ * Evaluation order matches Claude Code's permission flow:
+ *
+ *   1. `deny` rule match → `'deny'` (always wins, even in `bypass`).
+ *   2. `mode === 'bypass'` → `'allow'`.
+ *   3. `allow` rule match → `'allow'`.
+ *   4. `ask` rule match → `'ask'`.
+ *   5. `mode === 'dontAsk'` → `'deny'`.
+ *   6. fallthrough → `'ask'`.
+ *
+ * The returned callback is a single `HookCallback`, not a `HookMatcher` —
+ * register it under the matcher with the pattern you want (omit the
+ * pattern to fire on every tool call, which is the typical case since
+ * the policy itself does the filtering).
+ */
+export declare function createToolPolicyHook(config: ToolPolicyConfig): HookCallback<'PreToolUse'>;

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

@@ -1,6 +1,9 @@
 export { HookRegistry } from './HookRegistry';
+export type { HookHaltSignal } from './HookRegistry';
 export { executeHooks, DEFAULT_HOOK_TIMEOUT_MS } from './executeHooks';
 export { matchesQuery, hasNestedQuantifier, MAX_PATTERN_LENGTH, MAX_CACHE_SIZE, } from './matchers';
+export { createToolPolicyHook } from './createToolPolicyHook';
+export type { ToolPolicyMode, ToolPolicyConfig } from './createToolPolicyHook';
 export { HOOK_EVENTS } from './types';
-export type { HookEvent, HookInput, HookOutput, HookCallback, HookMatcher, HooksByEvent, HookInputByEvent, HookOutputByEvent, BaseHookInput, BaseHookOutput, ToolDecision, StopDecision, AggregatedHookResult, RunStartHookInput, UserPromptSubmitHookInput, PreToolUseHookInput, PostToolUseHookInput, PostToolUseFailureHookInput, PermissionDeniedHookInput, SubagentStartHookInput, SubagentStopHookInput, StopHookInput, StopFailureHookInput, PreCompactHookInput, PostCompactHookInput, RunStartHookOutput, UserPromptSubmitHookOutput, PreToolUseHookOutput, PostToolUseHookOutput, PostToolUseFailureHookOutput, PermissionDeniedHookOutput, SubagentStartHookOutput, SubagentStopHookOutput, StopHookOutput, StopFailureHookOutput, PreCompactHookOutput, PostCompactHookOutput, } from './types';
+export type { HookEvent, HookInput, HookOutput, HookCallback, HookMatcher, HooksByEvent, HookInputByEvent, HookOutputByEvent, BaseHookInput, BaseHookOutput, ToolDecision, StopDecision, AggregatedHookResult, RunStartHookInput, UserPromptSubmitHookInput, PreToolUseHookInput, PostToolUseHookInput, PostToolUseFailureHookInput, PostToolBatchHookInput, PostToolBatchEntry, PermissionDeniedHookInput, SubagentStartHookInput, SubagentStopHookInput, StopHookInput, StopFailureHookInput, PreCompactHookInput, PostCompactHookInput, RunStartHookOutput, UserPromptSubmitHookOutput, PreToolUseHookOutput, PostToolUseHookOutput, PostToolUseFailureHookOutput, PostToolBatchHookOutput, PermissionDeniedHookOutput, SubagentStartHookOutput, SubagentStopHookOutput, StopHookOutput, StopFailureHookOutput, PreCompactHookOutput, PostCompactHookOutput, } from './types';
 export type { ExecuteHooksOptions } from './executeHooks';

package/dist/types/hooks/types.d.ts

@@ -7,7 +7,7 @@ import type { BaseMessage } from '@langchain/core/messages';
  * `docs/hooks-design-report.md` §3.2 for the mapping to existing
  * `@librechat/agents` emission points.
  */
-export declare const HOOK_EVENTS: readonly ["RunStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "PostToolUseFailure", "PermissionDenied", "SubagentStart", "SubagentStop", "Stop", "StopFailure", "PreCompact", "PostCompact"];
+export declare const HOOK_EVENTS: readonly ["RunStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "PostToolUseFailure", "PostToolBatch", "PermissionDenied", "SubagentStart", "SubagentStop", "Stop", "StopFailure", "PreCompact", "PostCompact"];
 export type HookEvent = (typeof HOOK_EVENTS)[number];
 /** Tool-gating decision; executeHooks folds with `deny > ask > allow` precedence. */
 export type ToolDecision = 'allow' | 'deny' | 'ask';
@@ -75,6 +75,40 @@ export interface PostToolUseFailureHookInput extends BaseHookInput {
     stepId?: string;
     turn?: number;
 }
+/**
+ * Per-tool result snapshot included in a `PostToolBatch` event. Mirrors
+ * the data PostToolUse / PostToolUseFailure get individually, but the
+ * batch view lets a single hook see the whole set so it can inject one
+ * consolidated convention/audit message rather than N per-tool ones.
+ */
+export interface PostToolBatchEntry {
+    toolName: string;
+    toolInput: Record<string, unknown>;
+    toolUseId: string;
+    stepId?: string;
+    turn?: number;
+    /** Successful tool output, present only when `status === 'success'`. */
+    toolOutput?: unknown;
+    /** Error message, present only when `status === 'error'`. */
+    error?: string;
+    status: 'success' | 'error';
+}
+/**
+ * Fires once after every tool call in a single batch finishes (including
+ * any that were rejected via HITL). Lets a hook react to the batch as a
+ * whole — useful for "inject conventions once for the whole batch", batch
+ * audit logging, or coordinating cleanup that depends on knowing the full
+ * result set rather than streaming each tool's result independently.
+ *
+ * Order: fires AFTER all per-tool PostToolUse / PostToolUseFailure hooks
+ * for the same batch have completed, BEFORE the next model call. Pass an
+ * `additionalContext` to inject context for that next model turn.
+ */
+export interface PostToolBatchHookInput extends BaseHookInput {
+    hook_event_name: 'PostToolBatch';
+    /** All tool calls (and their outcomes) from this batch, in batch order. */
+    entries: PostToolBatchEntry[];
+}
 export interface PermissionDeniedHookInput extends BaseHookInput {
     hook_event_name: 'PermissionDenied';
     toolName: string;
@@ -128,7 +162,7 @@ export interface PostCompactHookInput extends BaseHookInput {
     messagesAfterCount: number;
 }
 /** Discriminated union of every hook input shape. */
-export type HookInput = RunStartHookInput | UserPromptSubmitHookInput | PreToolUseHookInput | PostToolUseHookInput | PostToolUseFailureHookInput | PermissionDeniedHookInput | SubagentStartHookInput | SubagentStopHookInput | StopHookInput | StopFailureHookInput | PreCompactHookInput | PostCompactHookInput;
+export type HookInput = RunStartHookInput | UserPromptSubmitHookInput | PreToolUseHookInput | PostToolUseHookInput | PostToolUseFailureHookInput | PostToolBatchHookInput | PermissionDeniedHookInput | SubagentStartHookInput | SubagentStopHookInput | StopHookInput | StopFailureHookInput | PreCompactHookInput | PostCompactHookInput;
 /** Compile-time map from event name to its input shape. */
 export type HookInputByEvent = {
     RunStart: RunStartHookInput;
@@ -136,6 +170,7 @@ export type HookInputByEvent = {
     PreToolUse: PreToolUseHookInput;
     PostToolUse: PostToolUseHookInput;
     PostToolUseFailure: PostToolUseFailureHookInput;
+    PostToolBatch: PostToolBatchHookInput;
     PermissionDenied: PermissionDeniedHookInput;
     SubagentStart: SubagentStartHookInput;
     SubagentStop: SubagentStopHookInput;
@@ -155,6 +190,56 @@ export interface BaseHookOutput {
     preventContinuation?: boolean;
     /** Reason reported alongside `preventContinuation`. */
     stopReason?: string;
+    /**
+     * Marks this hook output as fire-and-forget for INFLUENCE only.
+     * When `true`, the SDK skips every other field on this output —
+     * `decision`, `additionalContext`, `updatedInput`,
+     * `preventContinuation`, `allowedDecisions`, `updatedOutput` are
+     * all ignored. The hook's return value cannot block, modify, or
+     * inject context, so it's safe to use for pure side effects
+     * (logging, metrics, webhooks).
+     *
+     * Important caveat: the hook's CALLBACK promise is still awaited
+     * by `executeHooks` (subject to the matcher's timeout and the
+     * default `DEFAULT_HOOK_TIMEOUT_MS`). The SDK does not
+     * speculatively detach hooks based on output shape, because the
+     * shape is only known after the promise resolves. For TRUE
+     * fire-and-forget where the agent doesn't wait at all, the hook
+     * body should detach its side effect itself and return
+     * immediately:
+     *
+     * @example
+     * ```ts
+     * async (input) => {
+     *   // Detach the slow work — the SDK awaits this hook's
+     *   // returned promise, which resolves immediately because we
+     *   // don't `await` the side effect.
+     *   void sendToLoggingService(input).catch(console.error);
+     *   return { async: true };
+     * };
+     * ```
+     *
+     * @example WRONG — the agent will block on the webhook
+     * ```ts
+     * async (input) => {
+     *   await sendToLoggingService(input);  // ← awaited, blocks
+     *   return { async: true };  // returning async:true doesn't undo the await
+     * };
+     * ```
+     *
+     * Mirrors Claude Code Agent SDK's `async` output, with the same
+     * "detach inside the hook body" pattern.
+     */
+    async?: boolean;
+    /**
+     * Optional advisory timeout in milliseconds for the background work
+     * a host has detached inside an `async: true` hook body. The SDK
+     * does not enforce this (the hook's own AbortSignal handling does)
+     * but the field is preserved on the wire so downstream
+     * observability can surface long-running side effects. Ignored
+     * unless `async` is true.
+     */
+    asyncTimeout?: number;
 }
 export type RunStartHookOutput = BaseHookOutput;
 export interface UserPromptSubmitHookOutput extends BaseHookOutput {
@@ -175,6 +260,19 @@ export interface PreToolUseHookOutput extends BaseHookOutput {
      * `updatedInput` to one hook per matcher to avoid confusing precedence.
      */
     updatedInput?: Record<string, unknown>;
+    /**
+     * Restricts which decisions the host UI is allowed to surface for this
+     * tool call when the hook returns `decision: 'ask'`. Pass to lock a
+     * tool down to a subset of `'approve' | 'reject' | 'edit' | 'respond'`
+     * — for example, `['approve', 'reject']` to forbid the user from
+     * editing the tool's args or substituting a custom response.
+     *
+     * The values flow into the resulting interrupt's
+     * `review_configs[i].allowed_decisions`. Omitting the field keeps the
+     * SDK default (all four decisions advertised). Last-writer-wins in
+     * registration order, same precedence rules as `updatedInput`.
+     */
+    allowedDecisions?: ReadonlyArray<'approve' | 'reject' | 'edit' | 'respond'>;
 }
 export interface PostToolUseHookOutput extends BaseHookOutput {
     /**
@@ -186,6 +284,7 @@ export interface PostToolUseHookOutput extends BaseHookOutput {
     updatedOutput?: unknown;
 }
 export type PostToolUseFailureHookOutput = BaseHookOutput;
+export type PostToolBatchHookOutput = BaseHookOutput;
 export type PermissionDeniedHookOutput = BaseHookOutput;
 export interface SubagentStartHookOutput extends BaseHookOutput {
     decision?: ToolDecision;
@@ -206,6 +305,7 @@ export type HookOutputByEvent = {
     PreToolUse: PreToolUseHookOutput;
     PostToolUse: PostToolUseHookOutput;
     PostToolUseFailure: PostToolUseFailureHookOutput;
+    PostToolBatch: PostToolBatchHookOutput;
     PermissionDenied: PermissionDeniedHookOutput;
     SubagentStart: SubagentStartHookOutput;
     SubagentStop: SubagentStopHookOutput;
@@ -215,7 +315,7 @@ export type HookOutputByEvent = {
     PostCompact: PostCompactHookOutput;
 };
 /** Superset output shape used by the executor's fold loop. */
-export type HookOutput = RunStartHookOutput | UserPromptSubmitHookOutput | PreToolUseHookOutput | PostToolUseHookOutput | PostToolUseFailureHookOutput | PermissionDeniedHookOutput | SubagentStartHookOutput | SubagentStopHookOutput | StopHookOutput | StopFailureHookOutput | PreCompactHookOutput | PostCompactHookOutput;
+export type HookOutput = RunStartHookOutput | UserPromptSubmitHookOutput | PreToolUseHookOutput | PostToolUseHookOutput | PostToolUseFailureHookOutput | PostToolBatchHookOutput | PermissionDeniedHookOutput | SubagentStartHookOutput | SubagentStopHookOutput | StopHookOutput | StopFailureHookOutput | PreCompactHookOutput | PostCompactHookOutput;
 /**
  * A hook callback is a plain async function registered against a specific
  * event. The `signal` is always supplied by `executeHooks` and combines the
@@ -297,6 +397,12 @@ export interface AggregatedHookResult {
      * hook per matcher to avoid subtle precedence bugs.
      */
     updatedInput?: Record<string, unknown>;
+    /**
+     * Restricted decision set from a `PreToolUse` hook. Same last-writer-wins
+     * semantics as `updatedInput`. Surfaces to the interrupt payload's
+     * `review_configs[i].allowed_decisions`.
+     */
+    allowedDecisions?: ReadonlyArray<'approve' | 'reject' | 'edit' | 'respond'>;
     /**
      * Replacement tool output from a `PostToolUse` hook.
      *

package/dist/types/index.d.ts

@@ -23,7 +23,17 @@ export * from './tools/search';
 export * from './common';
 export * from './utils';
 export * from './hooks';
+export * from './hitl';
 export type * from './types';
+export * from './langchain';
+/**
+ * HITL primitives re-exported from `@langchain/langgraph` so hosts that
+ * build durable checkpoint savers, dispatch `Command({ resume })`, or
+ * detect interrupts can do so against the same langgraph instance the
+ * SDK was compiled against — avoiding accidental dual-version drift.
+ */
+export { Command, INTERRUPT, interrupt, MemorySaver, BaseCheckpointSaver, isInterrupted, } from '@langchain/langgraph';
+export type { Interrupt } from '@langchain/langgraph';
 export { CustomOpenAIClient } from './llm/openai';
 export { ChatOpenRouter } from './llm/openrouter';
 export type { OpenRouterReasoning, OpenRouterReasoningEffort, ChatOpenRouterCallOptions, } from './llm/openrouter';

package/dist/types/langchain/google-common.d.ts

@@ -0,0 +1 @@
+export type { GoogleAIToolType } from '@langchain/google-common';

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

@@ -0,0 +1,8 @@
+export * from './messages';
+export * from './prompts';
+export * from './runnables';
+export * from './tools';
+export * from './google-common';
+export * from './language_models/chat_models';
+export * from './messages/tool';
+export * from './openai';

package/dist/types/langchain/language_models/chat_models.d.ts

@@ -0,0 +1 @@
+export type { BindToolsInput } from '@langchain/core/language_models/chat_models';

package/dist/types/langchain/messages/tool.d.ts

@@ -0,0 +1 @@
+export type { InvalidToolCall, ToolCall, ToolCallChunk, } from '@langchain/core/messages/tool';

package/dist/types/langchain/messages.d.ts

@@ -0,0 +1,2 @@
+export { AIMessage, AIMessageChunk, BaseMessage, BaseMessageChunk, HumanMessage, SystemMessage, ToolMessage, getBufferString, isAIMessage, isBaseMessage, isToolMessage, } from '@langchain/core/messages';
+export type { BaseMessageFields, MessageContent, MessageContentText, MessageContentImageUrl, UsageMetadata, } from '@langchain/core/messages';

package/dist/types/langchain/openai.d.ts

@@ -0,0 +1 @@
+export type { AzureOpenAIInput } from '@langchain/openai';

package/dist/types/langchain/prompts.d.ts

@@ -0,0 +1 @@
+export { PromptTemplate } from '@langchain/core/prompts';

package/dist/types/langchain/runnables.d.ts

@@ -0,0 +1,2 @@
+export { Runnable, RunnableLambda, RunnableSequence, } from '@langchain/core/runnables';
+export type { RunnableConfig } from '@langchain/core/runnables';

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

@@ -0,0 +1,2 @@
+export { DynamicStructuredTool, StructuredTool, Tool, tool, } from '@langchain/core/tools';
+export type { StructuredToolInterface } from '@langchain/core/tools';

package/dist/types/langchain/utils/env.d.ts

@@ -0,0 +1 @@
+export { getEnvironmentVariable } from '@langchain/core/utils/env';

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

@@ -4,18 +4,31 @@ import type { BaseChatModelParams } from '@langchain/core/language_models/chat_m
 import type { BaseMessage, UsageMetadata } from '@langchain/core/messages';
 import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
 import type { AnthropicInput } from '@langchain/anthropic';
-import type { AnthropicMessageCreateParams, AnthropicStreamingMessageCreateParams, AnthropicOutputConfig } from '@/llm/anthropic/types';
+import type { Anthropic } from '@anthropic-ai/sdk';
+import type { AnthropicMessageCreateParams, AnthropicStreamingMessageCreateParams, AnthropicOutputConfig, AnthropicBeta, AnthropicMCPServerURLDefinition, AnthropicContextManagementConfigParam } from '@/llm/anthropic/types';
+export declare function _documentsInParams(params: AnthropicMessageCreateParams | AnthropicStreamingMessageCreateParams): boolean;
 export type CustomAnthropicInput = AnthropicInput & {
     _lc_stream_delay?: number;
     outputConfig?: AnthropicOutputConfig;
     inferenceGeo?: string;
-    contextManagement?: any;
+    contextManagement?: AnthropicContextManagementConfigParam;
 } & BaseChatModelParams;
-/**
- * A type representing additional parameters that can be passed to the
- * Anthropic API.
- */
-type Kwargs = Record<string, any>;
+export type CustomAnthropicCallOptions = {
+    outputConfig?: AnthropicOutputConfig;
+    outputFormat?: Anthropic.Messages.JSONOutputFormat;
+    inferenceGeo?: string;
+    betas?: AnthropicBeta[];
+    container?: string;
+    mcp_servers?: AnthropicMCPServerURLDefinition[];
+};
+type CustomAnthropicInvocationParams = {
+    betas?: AnthropicBeta[];
+    container?: string;
+    context_management?: AnthropicContextManagementConfigParam;
+    inference_geo?: string;
+    mcp_servers?: AnthropicMCPServerURLDefinition[];
+    output_config?: AnthropicOutputConfig;
+};
 export declare class CustomAnthropic extends ChatAnthropicMessages {
     _lc_stream_delay: number;
     private message_start;
@@ -25,13 +38,13 @@ export declare class CustomAnthropic extends ChatAnthropicMessages {
     top_k: number | undefined;
     outputConfig?: AnthropicOutputConfig;
     inferenceGeo?: string;
-    contextManagement?: any;
+    contextManagement?: AnthropicContextManagementConfigParam;
     constructor(fields?: CustomAnthropicInput);
     static lc_name(): 'LibreChatAnthropic';
     /**
      * Get the parameters used to invoke the model
      */
-    invocationParams(options?: this['ParsedCallOptions']): Omit<AnthropicMessageCreateParams | AnthropicStreamingMessageCreateParams, 'messages'> & Kwargs;
+    invocationParams(options?: this['ParsedCallOptions'] & CustomAnthropicCallOptions): Omit<AnthropicMessageCreateParams | AnthropicStreamingMessageCreateParams, 'messages'> & CustomAnthropicInvocationParams;
     /**
      * Get stream usage as returned by this client's API response.
      * @returns The stream usage object.

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

@@ -1,5 +1,7 @@
 import Anthropic from '@anthropic-ai/sdk';
-import { BindToolsInput } from '@langchain/core/language_models/chat_models';
+import type { BindToolsInput } from '@langchain/core/language_models/chat_models';
+import type { AnthropicBeta } from '@anthropic-ai/sdk/resources';
+export type { AnthropicBeta };
 export type AnthropicStreamUsage = Anthropic.Usage;
 export type AnthropicMessageDeltaEvent = Anthropic.MessageDeltaEvent;
 export type AnthropicMessageStartEvent = Anthropic.MessageStartEvent;
@@ -14,8 +16,10 @@ export type AnthropicMessageResponse = Anthropic.ContentBlock | AnthropicToolRes
 export type AnthropicMessageCreateParams = Anthropic.MessageCreateParamsNonStreaming;
 export type AnthropicStreamingMessageCreateParams = Anthropic.MessageCreateParamsStreaming;
 export type AnthropicThinkingConfigParam = Anthropic.ThinkingConfigParam;
+export type AnthropicContextManagementConfigParam = Anthropic.Beta.BetaContextManagementConfig;
 export type AnthropicMessageStreamEvent = Anthropic.MessageStreamEvent;
 export type AnthropicRequestOptions = Anthropic.RequestOptions;
+export type AnthropicMCPServerURLDefinition = Anthropic.Beta.Messages.BetaRequestMCPServerURLDefinition;
 export type AnthropicToolChoice = {
     type: 'tool';
     name: string;

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

@@ -1,10 +1,16 @@
-/**
- * This util file contains functions for converting Anthropic messages to LangChain messages.
- */
-import Anthropic from '@anthropic-ai/sdk';
+/** This util file contains functions for converting Anthropic messages to LangChain messages. */
 import { AIMessageChunk } from '@langchain/core/messages';
-import { ChatGeneration } from '@langchain/core/outputs';
-import { AnthropicMessageResponse } from '../types';
+import type Anthropic from '@anthropic-ai/sdk';
+import type { UsageMetadata } from '@langchain/core/messages';
+import type { ChatGeneration } from '@langchain/core/outputs';
+import type { AnthropicMessageResponse } from '../types';
+interface AnthropicUsageData {
+    input_tokens?: number | null;
+    output_tokens?: number | null;
+    cache_creation_input_tokens?: number | null;
+    cache_read_input_tokens?: number | null;
+}
+export declare function getAnthropicUsageMetadata(usage: AnthropicUsageData | null | undefined): UsageMetadata | undefined;
 export declare function _makeMessageChunkFromAnthropicEvent(data: Anthropic.Beta.Messages.BetaRawMessageStreamEvent, fields: {
     streamUsage: boolean;
     coerceContentToString: boolean;
@@ -12,3 +18,4 @@ export declare function _makeMessageChunkFromAnthropicEvent(data: Anthropic.Beta
     chunk: AIMessageChunk;
 } | null;
 export declare function anthropicResponseToChatMessages(messages: AnthropicMessageResponse[], additionalKwargs: Record<string, unknown>): ChatGeneration[];
+export {};

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

@@ -18,5 +18,5 @@ export declare class AnthropicToolsOutputParser<T extends Record<string, any> =
     protected _validateResult(result: unknown): Promise<T>;
     parseResult(generations: ChatGeneration[]): Promise<T>;
 }
-export declare function extractToolCalls(content: Record<string, any>[]): ToolCall[];
+export declare function extractToolCalls(content: Record<string, any>[]): ToolCall<string, Record<string, any>>[];
 export {};