librechat-data-provider 0.8.521 → 0.8.523

package/dist/types/stateful-code.d.ts

@@ -0,0 +1,7 @@
+export declare const STATEFUL_CODE_ENVIRONMENTS: readonly ["user", "agent-user", "conversation"];
+export type StatefulCodeEnvironment = (typeof STATEFUL_CODE_ENVIRONMENTS)[number];
+/** Resolve a deployment allowlist in stable UI order. An omitted value preserves
+ * the backward-compatible behavior where every environment is available. */
+export declare function resolveAllowedStatefulCodeEnvironments(configured?: readonly StatefulCodeEnvironment[] | null): StatefulCodeEnvironment[];
+/** Keep an allowed preference, otherwise select the first deployment-allowed scope. */
+export declare function resolveStatefulCodeEnvironment(preferred: StatefulCodeEnvironment | null | undefined, configured?: readonly StatefulCodeEnvironment[] | null): StatefulCodeEnvironment | undefined;

package/dist/types/svg.d.ts

@@ -0,0 +1,34 @@
+/**
+ * DOMPurify policy for user-provided SVG icons, shared by the browser uploader and
+ * the server trust boundary so a preview and the persisted icon cannot disagree.
+ * `use` is re-added for self-contained `<defs>` references (targets restricted by
+ * `restrictSvgReferences`); every SMIL element is forbidden so a stored icon
+ * cannot animate forever wherever it renders.
+ */
+export declare const SVG_SANITIZE_CONFIG: {
+    USE_PROFILES: {
+        svg: boolean;
+        svgFilters: boolean;
+    };
+    ADD_TAGS: string[];
+    ADD_ATTR: string[];
+    FORBID_TAGS: string[];
+    FORBID_ATTR: string[];
+};
+/** Element surface shared by the browser DOM and the server's jsdom. */
+export interface SvgAttributeHost {
+    attributes: ArrayLike<{
+        name: string;
+    }>;
+    getAttribute(name: string): string | null;
+    removeAttribute(name: string): void;
+}
+/** DOMPurify hook that drops every attribute referencing outside the document. */
+export declare function restrictSvgReferences(node: SvgAttributeHost): void;
+/**
+ * Makes HTML-mode sanitizer output valid as a standalone `image/svg+xml`
+ * document: restores camelCase element names the HTML parser lowercased and
+ * declares the SVG namespace on the root, without which an XML parser puts the
+ * root in no namespace and the icon renders blank.
+ */
+export declare function finalizeSvgMarkup(markup: string): string;

package/dist/types/types/agents.d.ts

@@ -1,6 +1,6 @@
 import type { TTokenUsageEvent, TContextUsageEvent, TPendingSteer } from './runs';
-import type { FunctionToolCall, SummaryContentPart } from './assistants';
 import type { TAttachment, TPlugin } from 'src/schemas';
+import type { SummaryContentPart } from './assistants';
 import { StepTypes, ContentTypes, ToolCallTypes } from './runs';
 export declare namespace Agents {
     type MessageType = 'human' | 'ai' | 'generic' | 'system' | 'function' | 'tool' | 'remove';
@@ -52,16 +52,40 @@ export declare namespace Agents {
      * A call to a tool.
      */
     type ToolCall = {
-        /** Type ("tool_call") according to Assistants Tool Call Structure */
-        type: ToolCallTypes.TOOL_CALL;
+        /** Type ("tool_call") according to Assistants Tool Call Structure; optional literal
+         *  form included to mirror langchain's ToolCall, whose `type` is optional. */
+        type?: ToolCallTypes.TOOL_CALL | 'tool_call';
         /** The name of the tool to be called */
         name: string;
+        /** Host-derived MCP server identity retained to disambiguate historical tool keys. */
+        mcpServerName?: string;
         /** The arguments to the tool call */
         args?: string | Record<string, any>;
         /** If provided, an identifier associated with the tool call */
         id?: string;
+        /** Host run-step identity; unlike provider ids, this is unique across turns. */
+        stepId?: string;
         /** If provided, the output of the tool call */
         output?: string;
+        /** Host-owned durable receipt for a detached ordinary tool result.
+         * It lives beside the original call so reload, manual collection, and
+         * automatic continuation all arbitrate the same result identity. */
+        backgroundTask?: {
+            version: 1;
+            taskId: string;
+            toolName: string;
+            status: 'completed' | 'error';
+            /** Additive rolling-deploy-compatible cancellation discriminator. */
+            cancelled?: true;
+            settledAt: Date;
+            resultClaim?: {
+                kind: 'manual' | 'wakeup';
+                claimId: string;
+                claimedAt: Date;
+                /** Response generation that owns a manual delivery claim. */
+                generationId?: string;
+            };
+        };
         /** The tool call was rejected before execution because its input failed schema validation. */
         inputValidationError?: true;
         /** Auth URL */
@@ -177,7 +201,35 @@ export declare namespace Agents {
         groupId?: number;
         stepDetails: StepDetails;
         summary?: SummaryContentPart;
-        usage: null | object;
+        /** Optional to mirror the agents SDK, which omits usage until a step reports it. */
+        usage?: null | object;
+        /** Epoch ms the step was opened. Emitted by `@librechat/agents` >= 3.4.6. */
+        created_at?: number;
+        status?: RunStepStatus;
+    };
+    /** Lifecycle status of a run step. `in_progress` until a terminal close. */
+    type RunStepStatus = 'in_progress' | 'completed' | 'cancelled' | 'failed';
+    /** Terminal status a run step can close with. */
+    type RunStepClosedStatus = Exclude<RunStepStatus, 'in_progress'>;
+    /**
+     * Payload of {@link StepEvents.ON_RUN_STEP_CLOSED}. Emitted once per step
+     * when it reaches a terminal state, including steps swept at end-of-run
+     * because the caller aborted — which is the only signal that distinguishes
+     * a stopped step from one still in flight.
+     */
+    type RunStepClosedEvent = {
+        id: string;
+        index: number;
+        type: StepTypes;
+        status: RunStepClosedStatus;
+        /** Epoch ms the step was opened, when the emitter knows it. */
+        created_at?: number;
+        /** Epoch ms the step reached its terminal state. */
+        closed_at: number;
+        runId?: string;
+        agentId?: string;
+        groupId?: number;
+        stepIndex?: number;
     };
     /** Content part for aggregated message content */
     interface ContentPart {
@@ -197,6 +249,16 @@ export declare namespace Agents {
         manualSkills?: string[];
         alwaysAppliedSkills?: string[];
     }
+    /** Client-safe state for one MCP authorization prompt that remains actionable. */
+    interface PendingMCPOAuthPrompt {
+        stepId: string;
+        runId?: string;
+        index: number;
+        toolCallId?: string;
+        toolName: string;
+        authURL: string;
+        expiresAt?: number;
+    }
     /** State data sent to reconnecting clients */
     interface ResumeState {
         runSteps: RunStep[];
@@ -204,6 +266,8 @@ export declare namespace Agents {
         aggregatedContent?: MessageContentComplex[];
         userMessage?: UserMessageMeta;
         responseMessageId?: string;
+        /** True when the live generation replaces an existing assistant branch. */
+        isRegenerate?: boolean;
         conversationId?: string;
         sender?: string;
         iconURL?: string;
@@ -220,6 +284,8 @@ export declare namespace Agents {
             data?: unknown;
             [key: string]: unknown;
         }>;
+        /** Pending MCP authorization prompts projected from durable stream state. */
+        pendingOAuthPrompts?: PendingMCPOAuthPrompt[];
         /** Cumulative provider-reported usage for the run; backfills usage totals on resume */
         collectedUsage?: TTokenUsageEvent[];
         /** Latest context window snapshot; restores the usage gauge on resume */
@@ -263,7 +329,7 @@ export declare namespace Agents {
     };
     type ToolCallsDetails = {
         type: StepTypes.TOOL_CALLS;
-        tool_calls: AgentToolCall[];
+        tool_calls?: AgentToolCall[];
     };
     type ToolCallDelta = {
         type: StepTypes.TOOL_CALLS | string;
@@ -277,7 +343,21 @@ export declare namespace Agents {
             description?: string;
         };
     };
-    type AgentToolCall = FunctionToolCall | ToolCall;
+    /**
+     * Mirrors the agents SDK's function tool-call variant: `arguments` may arrive as a
+     * parsed object, and `output` is attached by LibreChat aggregation only once available
+     * (the legacy assistants `FunctionToolCall` requires both as string/present).
+     */
+    type AgentFunctionToolCall = {
+        id: string;
+        type: 'function';
+        function: {
+            name: string;
+            arguments: string | object;
+            output?: string | null;
+        };
+    };
+    type AgentToolCall = AgentFunctionToolCall | ToolCall;
     /**
      * Human-in-the-loop interrupt categories. The discriminator on
      * {@link HumanInterruptPayload}.
@@ -307,6 +387,8 @@ export declare namespace Agents {
         tool_call_id: string;
         /** Optional human-readable description shown alongside the prompt */
         description?: string;
+        /** Server-authored provenance. Absent for user, MCP, action, and older tool calls. */
+        source?: 'librechat_code';
     }
     /**
      * Per-call review configuration: which decisions the user is allowed to make.
@@ -409,6 +491,8 @@ export declare namespace Agents {
          * so the id check can't.
          */
         requestFingerprint?: string;
+        /** Current-version fingerprint; server-only and omitted from client projections. */
+        requestFingerprintV2?: string;
         /**
          * Graph-determining request fields (endpoint, agent_id, model, spec, promptPrefix,
          * ephemeralAgent) captured at pause. The resume route REPLAYS these onto the request
@@ -416,6 +500,22 @@ export declare namespace Agents {
          * no longer reconstruct the ephemeral config — still rebuilds the same agent/graph.
          */
         resumeContext?: Record<string, unknown>;
+        /**
+         * Opaque, server-only identity of the stateful code targets selected when a
+         * tool approval paused. Resume rejects a changed target before provider or
+         * tool execution so an approval cannot migrate to another VM or workspace.
+         */
+        codeExecutionBinding?: CodeExecutionApprovalBinding;
+    }
+    interface CodeExecutionApprovalTargetBinding {
+        /** Agent identity when available; anonymous ephemeral agents use null. */
+        agentId: string | null;
+        /** SHA-256 of the resolved route, worker and runtime-session identity. */
+        targetHash: string;
+    }
+    interface CodeExecutionApprovalBinding {
+        version: 1;
+        targets: CodeExecutionApprovalTargetBinding[];
     }
     /**
      * Scope of a tool-approval decision — drives the "remember this" persistence
@@ -646,8 +746,17 @@ export type GraphEdge = {
      *
      * For handoff edges: Description for the input parameter that the handoff tool accepts,
      * allowing the supervisor to pass specific instructions/context to the transferred agent.
+     *
+     * The callback receives a minimal structural view of the run's messages (data-provider
+     * cannot depend on langchain's BaseMessage): every langchain message satisfies
+     * `{ content: unknown }`, and callbacks typed against richer structural message shapes
+     * remain assignable. The promise branch mirrors the agents SDK signature exactly —
+     * widening it (e.g. to `Promise<string | undefined>`) would break assignability of
+     * stored edges into the SDK's `GraphEdge`.
      */
-    prompt?: string | ((messages: BaseMessage[], runStartIndex: number) => string | undefined);
+    prompt?: string | ((messages: {
+        content: unknown;
+    }[], runStartIndex: number) => string | Promise<string> | undefined);
     /**
      * When true, excludes messages from startIndex when adding prompt.
      * Automatically set to true when {results} variable is used in prompt.

package/dist/types/types/assistants.d.ts

@@ -1,9 +1,13 @@
+import { z } from 'zod';
 import type { OpenAPIV3 } from 'openapi-types';
-import type { AssistantsEndpoint, AgentProvider, MemoryScope } from 'src/schemas';
+import type { AssistantsEndpoint, AgentProvider, MemoryScope, SkillsScope } from 'src/schemas';
+import type { StatefulCodeEnvironment } from '../stateful-code';
+import type { ContentTypes, SubagentIdentity } from './runs';
 import type { Agents, GraphEdge } from './agents';
-import type { ContentTypes } from './runs';
 import type { TFile } from './files';
 import { ArtifactModes } from 'src/artifacts';
+export { STATEFUL_CODE_ENVIRONMENTS, resolveStatefulCodeEnvironment, resolveAllowedStatefulCodeEnvironments, } from '../stateful-code';
+export type { StatefulCodeEnvironment } from '../stateful-code';
 export type Schema = OpenAPIV3.SchemaObject & {
     description?: string;
 };
@@ -238,15 +242,46 @@ export type AgentToolOptions = Record<string, ToolOptions>;
 /**
  * Configuration for spawning subagents (isolated-context child agents) from an agent.
  * When `enabled` is true, the agent gets a subagent-spawn tool that can delegate work
- * to either itself (when `allowSelf` is true) and/or the listed `agent_ids`.
+ * to itself, listed single-agent targets, and/or explicit saved-agent teams.
  */
+export type AgentSubagentGraphEdge = Omit<GraphEdge, 'edgeType' | 'condition' | 'prompt' | 'promptKey'> & {
+    edgeType: 'direct';
+    condition?: never;
+    prompt?: string;
+    promptKey?: never;
+};
+/** A bounded saved-agent team that can be spawned as one isolated child graph. */
+export type AgentSubagentGraph = {
+    /** Stable spawn-tool enum value for the team. */
+    type: string;
+    name: string;
+    description: string;
+    /** Member IDs. In create/update payloads, an empty ID refers to the current agent. */
+    agent_ids: string[];
+    edges: AgentSubagentGraphEdge[];
+    /** Entry member ID. In create/update payloads, an empty ID refers to the current agent. */
+    entry_agent_id: string;
+    /** Result member ID. In create/update payloads, an empty ID refers to the current agent. */
+    result_agent_id: string;
+};
 export type AgentSubagentsConfig = {
     enabled?: boolean;
     /** When true (default), the agent may spawn itself in an isolated context. */
     allowSelf?: boolean;
+    /** Share current-turn files with authorized descendants. Off unless explicitly enabled. */
+    shareFiles?: boolean;
     /** Specific agents that may be spawned as subagents. */
     agent_ids?: string[];
+    /** Explicit saved-agent teams that may be spawned as bounded child graphs. */
+    graphs?: AgentSubagentGraph[];
+};
+export type AgentGitIdentity = {
+    /** Commit author and committer display name. */
+    name: string;
+    /** Commit author and committer email address. */
+    email: string;
 };
+export declare const agentGitIdentitySchema: z.ZodType<AgentGitIdentity | undefined>;
 export type Agent = {
     _id?: string;
     id: string;
@@ -275,6 +310,14 @@ export type Agent = {
     hide_sequential_outputs?: boolean;
     /** Per-agent opt-in for stateful code sessions (requires the app-level capability). */
     stateful_code_sessions?: boolean;
+    /** Stateful workspace sharing scope. Defaults to one workspace per user. */
+    stateful_code_environment?: StatefulCodeEnvironment;
+    /** Operator-configured managed or attached stateful execution environment. */
+    code_environment_id?: string | null;
+    /** Default attached workspace for new chats; empty means no agent default. */
+    code_workspace_id?: string;
+    /** Non-secret Git authorship injected into this agent's sandboxed commands. */
+    git_identity?: AgentGitIdentity | null;
     artifacts?: ArtifactModes;
     recursion_limit?: number;
     isPublic?: boolean;
@@ -297,11 +340,17 @@ export type Agent = {
     owner_contact?: AgentOwnerContact;
     /** Per-tool configuration options (deferred loading, allowed callers, etc.) */
     tool_options?: AgentToolOptions;
+    /** Attached action registrations, each `${encodedDomain}${actionDelimiter}${action_id}` */
+    actions?: string[];
     /** Optional allowlist of skill ObjectIds. Only applies when `skills_enabled`. */
     skills?: string[];
     /** Master toggle for skill use on this agent. `true` = active (full catalog unless
      *  `skills` narrows it). `false`/undefined = inactive (no skills available). */
     skills_enabled?: boolean;
+    /** Enables runtime skill creation without exposing an existing skill catalog. */
+    skill_authoring_enabled?: boolean;
+    /** Explicit catalog exposure while skills are enabled. Missing preserves legacy semantics. */
+    skills_scope?: SkillsScope;
     /** Subagent spawning configuration — isolated-context child agents. */
     subagents?: AgentSubagentsConfig;
     /** Memory partition: `agent` isolates memories per (user, agent); default shared pool */
@@ -309,6 +358,7 @@ export type Agent = {
 };
 export type TAgentsMap = Record<string, Agent | undefined>;
 export type AgentCreateParams = {
+    git_identity?: AgentGitIdentity;
     name?: string | null;
     description?: string | null;
     avatar?: AgentAvatar | null;
@@ -318,7 +368,7 @@ export type AgentCreateParams = {
     provider: AgentProvider;
     model: string | null;
     model_parameters: AgentModelParameters;
-} & Pick<Agent, 'agent_ids' | 'edges' | 'end_after_tools' | 'hide_sequential_outputs' | 'stateful_code_sessions' | 'artifacts' | 'recursion_limit' | 'category' | 'support_contact' | 'tool_options' | 'skills' | 'skills_enabled' | 'subagents' | 'memory_scope'>;
+} & Pick<Agent, 'agent_ids' | 'edges' | 'end_after_tools' | 'hide_sequential_outputs' | 'stateful_code_sessions' | 'stateful_code_environment' | 'code_environment_id' | 'code_workspace_id' | 'artifacts' | 'recursion_limit' | 'category' | 'support_contact' | 'tool_options' | 'skills' | 'skills_enabled' | 'skill_authoring_enabled' | 'skills_scope' | 'subagents' | 'memory_scope'>;
 export type AgentUpdateParams = {
     name?: string | null;
     description?: string | null;
@@ -330,7 +380,7 @@ export type AgentUpdateParams = {
     provider?: AgentProvider;
     model?: string | null;
     model_parameters?: AgentModelParameters;
-} & Pick<Agent, 'agent_ids' | 'edges' | 'end_after_tools' | 'hide_sequential_outputs' | 'stateful_code_sessions' | 'artifacts' | 'recursion_limit' | 'category' | 'support_contact' | 'tool_options' | 'skills' | 'skills_enabled' | 'subagents' | 'memory_scope'>;
+} & Pick<Agent, 'agent_ids' | 'edges' | 'end_after_tools' | 'hide_sequential_outputs' | 'stateful_code_sessions' | 'stateful_code_environment' | 'code_environment_id' | 'git_identity' | 'code_workspace_id' | 'artifacts' | 'recursion_limit' | 'category' | 'support_contact' | 'tool_options' | 'skills' | 'skills_enabled' | 'skill_authoring_enabled' | 'skills_scope' | 'subagents' | 'memory_scope'>;
 export type AgentListParams = {
     limit?: number;
     requiredPermission: number;
@@ -478,6 +528,8 @@ export declare enum RunStatus {
     EXPIRED = "expired"
 }
 export type PartMetadata = {
+    /** Host-resolved execution identity for a saved subagent invocation. */
+    subagentIdentity?: SubagentIdentity;
     progress?: number;
     asset_pointer?: string;
     status?: string;
@@ -490,9 +542,46 @@ export type PartMetadata = {
     agentId?: string;
     /** Group ID for parallel content - parts with same groupId are displayed in columns */
     groupId?: number;
+    /**
+     * Terminal lifecycle status of the run step that produced this part, from
+     * `on_run_step_closed`. Distinct from `status`, which is already claimed by
+     * activity-label and question-form parts. Absent on parts predating the
+     * event or from endpoints that do not emit it, in which case renderers fall
+     * back to inferring "stopped" from `progress` and `isSubmitting`.
+     */
+    runStepStatus?: Agents.RunStepClosedStatus;
+    /**
+     * Wall-clock milliseconds the run step took, derived from the same
+     * `on_run_step_closed` event as {@link runStepStatus} via
+     * `getRunStepDurationMs`. Only written when the event carried both
+     * timestamps and they agree in order — so its absence means "not
+     * derivable", never "instant". The raw value is persisted unfiltered;
+     * whether it is worth showing (`isReportableRunStepDuration`) is decided
+     * at render time.
+     */
+    runStepDurationMs?: number;
+    /**
+     * Stamped by the background harvester when a detached task's final output
+     * replaces the dispatch handle in `tool_call.output`. The handle JSON and
+     * the live status-marker attachment are both transient, so after the patch
+     * (or a reload) this is the only signal that the call ran in the
+     * background — renderers use it to keep treating {@link runStepDurationMs}
+     * as dispatch time rather than the task's runtime.
+     */
+    backgrounded?: boolean;
+    /**
+     * Content index this part occupied while its run streamed. The aggregator
+     * writes parts at provider-source indexes, so the streamed array is sparse;
+     * persistence compacts it and every part after a hole shifts down. The
+     * client's final handler stamps the streamed position onto the compacted
+     * parts it adopts, so index-derived render identity survives the swap
+     * instead of remounting the settled message. Client-only and absent
+     * everywhere else — persisted content never carries it.
+     */
+    streamedIndex?: number;
 };
 /** Metadata for parallel content rendering - subset of PartMetadata */
-export type ContentMetadata = Pick<PartMetadata, 'agentId' | 'groupId'>;
+export type ContentMetadata = Pick<PartMetadata, 'agentId' | 'groupId' | 'streamedIndex'>;
 export type ContentPart = (CodeToolCall | RetrievalToolCall | FileSearchToolCall | FunctionToolCall | Agents.AgentToolCall | ImageFile | Text) & PartMetadata;
 export type TextData = (Text & PartMetadata) | undefined;
 export type SummaryContentPart = {
@@ -503,6 +592,13 @@ export type SummaryContentPart = {
     }>;
     tokenCount?: number;
     summarizing?: boolean;
+    /** A summarize round that ended in error. Partial deltas already streamed
+     *  into this slot are kept, so the renderer needs this to avoid presenting
+     *  truncated text under the "Conversation summarized" label. */
+    failed?: boolean;
+    /** Set when the user compacted the context manually rather than the
+     *  automatic detour firing on context pressure. */
+    initiatedBy?: 'user';
     summaryVersion?: number;
     model?: string;
     provider?: string;
@@ -528,6 +624,10 @@ export type SteerContentPart = {
     /** Attachments steered with the message; re-encoded per turn on replay
      *  like any other user-message media (refs only, never encoded data). */
     files?: Partial<TFile>[];
+    /** Quoted excerpts steered with the message, persisted separately from the
+     *  typed text (mirroring `TMessage.quotes`) so the UI renders them as
+     *  reference blocks; merged into the model-bound user turn on every replay. */
+    quotes?: string[];
 };
 export type TMessageContentParts = ({
     type: ContentTypes.ERROR;
@@ -536,6 +636,21 @@ export type TMessageContentParts = ({
 } & ContentMetadata) | ({
     type: ContentTypes.THINK;
     think?: string | TextData;
+    /** Generated orientation for this user-visible reasoning step. */
+    reasoning_label?: string;
+    /** Stable SDK run-step identity used to correlate live revisions. */
+    reasoning_label_step_id?: string;
+    /** Durable provider-call count used to enforce the per-run cost cap across resumes. */
+    reasoning_label_attempts?: number;
+    /** Visible reasoning length included in this step's latest provider call. */
+    reasoning_label_submitted_chars?: number;
+    /** Monotonic provider-call revision; gaps are allowed after unsuccessful attempts. */
+    reasoning_label_revision?: number;
+    /** Whether the reasoning step can still produce a newer label. */
+    reasoning_label_status?: 'streaming' | 'complete';
+    /** The reasoning happened but its text is not available to this view
+     *  (e.g. detached subagent projections retain only a marker). */
+    reasoning_unavailable?: boolean;
 } & ContentMetadata) | (SteerContentPart & ContentMetadata) | ({
     type: ContentTypes.TEXT;
     text?: string | TextData;

package/dist/types/types/files.d.ts

@@ -1,4 +1,5 @@
-import type { CodeEnvRef } from '../codeEnvRef';
+import type { TDefaultLLMDeliveryPathConfig } from '../file-config';
+import type { CodeEnvRef, CodeEnvRefMap } from '../codeEnvRef';
 import { EToolResources } from './assistants';
 export declare enum FileSources {
     local = "local",
@@ -26,6 +27,7 @@ export declare enum FileContext {
     image_generation = "image_generation",
     assistants_output = "assistants_output",
     message_attachment = "message_attachment",
+    run_artifact = "run_artifact",
     skill_file = "skill_file",
     filename = "filename",
     updatedAt = "updatedAt",
@@ -44,6 +46,8 @@ export type EndpointFileConfig = {
     fileSizeLimit?: number;
     totalSizeLimit?: number;
     supportedMimeTypes?: RegexLike[];
+    defaultLLMDeliveryPath?: TDefaultLLMDeliveryPathConfig;
+    legacyFileUploadUX?: boolean;
 };
 export type FileConfig = {
     endpoints: {
@@ -53,6 +57,10 @@ export type FileConfig = {
         fileSizeLimit?: number;
     };
     fileTokenLimit?: number;
+    /** Maximum aggregate model-bound attachment bytes admitted into one agent turn. */
+    fileContextSizeLimit?: number;
+    /** Maximum aggregate extracted-text characters admitted into one agent turn. */
+    fileContextCharLimit?: number;
     serverFileSizeLimit?: number;
     avatarSizeLimit?: number;
     clientImageResize?: {
@@ -60,6 +68,8 @@ export type FileConfig = {
         maxWidth?: number;
         maxHeight?: number;
         quality?: number;
+        /** Set when `enabled` came from the admin config, in which case it wins over the user's setting */
+        enforced?: boolean;
     };
     ocr?: {
         supportedMimeTypes?: RegexLike[];
@@ -71,6 +81,8 @@ export type FileConfig = {
         supportedMimeTypes?: RegexLike[];
     };
     checkType?: (fileType: string, supportedTypes: RegexLike[]) => boolean;
+    defaultLLMDeliveryPath?: TDefaultLLMDeliveryPathConfig;
+    legacyFileUploadUX?: boolean;
 };
 export type FileConfigInput = {
     endpoints?: {
@@ -81,6 +93,8 @@ export type FileConfigInput = {
     };
     serverFileSizeLimit?: number;
     avatarSizeLimit?: number;
+    fileContextSizeLimit?: number;
+    fileContextCharLimit?: number;
     clientImageResize?: {
         enabled?: boolean;
         maxWidth?: number;
@@ -97,6 +111,20 @@ export type FileConfigInput = {
         supportedMimeTypes?: string[];
     };
     checkType?: (fileType: string, supportedTypes: RegexLike[]) => boolean;
+    defaultLLMDeliveryPath?: TDefaultLLMDeliveryPathConfig;
+    legacyFileUploadUX?: boolean;
+};
+/** The immutable origin of a file explicitly published from an agent execution. */
+export type RunFileProvenance = {
+    runId: string;
+    executionId: string;
+    agentId: string;
+    parentExecutionId?: string;
+    parentAgentId?: string;
+    recipientAgentIds?: string[];
+    sourceFileId: string;
+    publishedAt: string;
+    inputFileIds: string[];
 };
 export type TFile = {
     _id?: string;
@@ -148,6 +176,7 @@ export type TFile = {
      */
     previewError?: string;
     metadata?: {
+        runFile?: RunFileProvenance;
         fileIdentifier?: string;
         /**
          * Structured form of `fileIdentifier`. Persisted alongside the
@@ -155,7 +184,17 @@ export type TFile = {
          * resolve via `resolveCodeEnvRef`.
          */
         codeEnvRef?: CodeEnvRef;
+        codeEnvRefs?: CodeEnvRefMap;
+        /** Dispatch-order stamp for the current source artifact generation. */
+        sourceDispatchedAt?: number;
+        /** Vector namespaces this file has been embedded into. */
+        embeddedEntities?: string[];
+        /** The user named this destination, so absent ones were declined. */
+        destinationChosen?: boolean;
+        /** The type the delivery route was resolved against, when conversion changed it. */
+        routingMimeType?: string;
     };
+    llmDeliveryPath?: 'provider' | 'text' | 'none';
     createdAt?: string | Date;
     updatedAt?: string | Date;
 };
@@ -230,7 +269,9 @@ export type TFilesUsageResponse = {
 };
 export type DeleteFilesResponse = {
     message: string;
-    result: Record<string, unknown>;
+    result?: Record<string, unknown>;
+    deletedFileIds?: string[];
+    failedFileIds?: string[];
 };
 export type BatchFile = {
     file_id: string;
@@ -251,4 +292,7 @@ export type DeleteMutationOptions = {
     onSuccess?: (data: DeleteFilesResponse, variables: DeleteFilesBody, context?: unknown) => void;
     onMutate?: (variables: DeleteFilesBody) => void | Promise<unknown>;
     onError?: (error: unknown, variables: DeleteFilesBody, context?: unknown) => void;
+    /** Suppresses the result toasts. Background cleanup runs on a timer the user never asked for,
+     * and a storage failure that keeps failing would otherwise announce itself on every retry. */
+    silent?: boolean;
 };

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

@@ -1,2 +1,4 @@
 export * from './queries';
 export * from './mcpServers';
+export * from './subagents';
+export * from './queuedTurns';

package/dist/types/types/insights.d.ts

@@ -0,0 +1,71 @@
+export type InsightsRange = '24h' | '7d' | '30d' | 'custom';
+export declare const INSIGHTS_MAX_RANGE_DAYS = 30;
+export declare const INSIGHTS_SEARCH_MIN_LENGTH = 3;
+export declare const INSIGHTS_SEARCH_MAX_LENGTH = 200;
+export declare const INSIGHTS_AGENT_ID_MAX_LENGTH = 256;
+export type TInsightsParams = {
+    range?: InsightsRange;
+    fromTimestamp?: string;
+    toTimestamp?: string;
+    timeZone?: string;
+    search?: string;
+    agentIds?: string[];
+    page?: number;
+    pageSize?: number;
+};
+export type TInsightsAgent = {
+    id: string;
+    name: string;
+};
+export type TInsightsDailyPoint = {
+    date: string;
+    conversations: number;
+    users: number;
+    messages: number;
+    totalTokens: number;
+};
+export type TInsightsUser = {
+    userId: string;
+    name: string;
+    email: string;
+    conversations: number;
+    messages: number;
+};
+export type TInsightsChurnedUser = TInsightsUser & {
+    firstSeen: string;
+    lastSeen: string;
+};
+export type TInsightsConversation = {
+    conversationId: string;
+    agentId: string;
+    agentName: string;
+    date: string;
+    userId: string;
+    name: string;
+    email: string;
+    firstMessage: string;
+    messages: number;
+    totalTokens: number;
+};
+export type TInsightsSummary = {
+    totalUsers: number;
+    totalConversations: number;
+    totalMessages: number;
+    totalTokens: number;
+};
+export type TInsightsResponse = {
+    agents: TInsightsAgent[];
+    summary: TInsightsSummary;
+    daily: TInsightsDailyPoint[];
+    topUsers: TInsightsUser[];
+    churnedUsers: TInsightsChurnedUser[];
+    latest: {
+        conversations: TInsightsConversation[];
+        page: number;
+        pageSize: number;
+        pages: number;
+    };
+};
+export type TInsightsAccessResponse = {
+    access: boolean;
+};