librechat-data-provider 0.8.522 → 0.8.524

package/dist/types/types/runs.d.ts

@@ -234,6 +234,10 @@ export type TTokenBudgetBreakdown = {
     toolTokenCounts?: Record<string, number>;
     /** Names of counted tools that are deferred (`defer_loading`) and discovered */
     deferredToolNames?: string[];
+    /** Calibrated retained tool traffic: tool results plus assistant turns made only of tool calls, inline provider tool results and reasoning. A subset of messageTokens, not an additional budget category. */
+    toolMessageTokens?: number;
+    /** Per-tool result-message share; excludes assistant invocation overhead. */
+    toolMessageTokenCounts?: Record<string, number>;
 };
 /** Per-model-call context snapshot, dispatched after pruning and before the LLM call. */
 export type TContextUsageEvent = {
@@ -249,12 +253,30 @@ export type TContextUsageEvent = {
     /** Tokens still free after instructions + pruned messages */
     remainingContextTokens?: number;
     calibrationRatio?: number;
+    /** Model and provider of the reconciling primary call, retained across reloads. */
+    model?: string;
+    provider?: string;
+    /** Cache portions of that call's prompt, in normalized display units. */
+    cacheRead?: number;
+    cacheWrite?: number;
     /** Output tokens of the response's final model call (the call this pre-invoke
-     *  snapshot precedes). Populated only on the persisted `metadata.contextUsage`
-     *  blob so a reloaded multi-call turn adds the same post-snapshot delta the
+     *  snapshot precedes). Saved in message metadata and used by the client so a
+     *  reloaded multi-call turn adds the same post-snapshot delta the
      *  live finalizer did — not the full response `tokenCount`, which the snapshot
      *  already includes for earlier steps. */
     completedOutputTokens?: number;
+    /** Completed output in a resumable job. Separate from the saved-message field
+     * so older clients do not add it alongside their trailing-text estimate. */
+    resumedOutputTokens?: number;
+    /** Tool-result tokens retained AFTER this pre-invoke snapshot, counted with the
+     *  run's own tokenizer. A run that stops at the tool-call limit keeps the result
+     *  its final call's tools produced, and no later snapshot describes it: the
+     *  snapshot precedes the call, and the limit means no further call is made. The
+     *  client adds this the way it adds `completedOutputTokens`, so the gauge and the
+     *  tool-call share include the retained result instead of missing it until the
+     *  next turn's snapshot carries it as kept-message context. Counted, never
+     *  estimated — the per-tool `toolMessageTokenCounts` stay a subset of the share. */
+    retainedToolTokens?: number;
 };
 /**
  * Per-response usage rollup persisted on `responseMessage.metadata.usage`, in
@@ -310,14 +332,19 @@ export declare const promptTokensFromUsage: (event: TTokenUsageEvent) => number;
 /**
  * Reconciles a pre-invoke context snapshot's CALIBRATED estimate to a call's
  * ACTUAL prompt tokens. The SDK's calibration multiplier scales only
- * `messageTokens` (instructions/summary are raw tiktoken counts), and it can
+ * `messageTokens` (instructions/summary are raw tiktoken counts) and can
  * over-shoot badly when a provider injects server-side content the SDK never
  * counted (e.g. Anthropic web search) — pinning the gauge several× too high and
  * persisting it. Trust the provider's own prompt count: keep the raw
- * instruction/summary rows, set `messageTokens` to the remainder, and recompute
- * the free space. No-op when `promptTokens` is unusable.
+ * instruction/summary rows, set `messageTokens` to the remainder, recompute the
+ * free space, and rescale the `toolMessageTokens` share to the new message
+ * total. No-op when `promptTokens` is unusable.
  */
 export declare const reconcileContextUsage: (snapshot: TContextUsageEvent, promptTokens: number) => TContextUsageEvent;
+/** Provider output, including reasoning omitted from an under-reported output count. */
+export declare const outputTokensFromUsage: (event: TTokenUsageEvent) => number;
+/** Reconcile and retain the primary call details on live, saved, and resumable snapshots. */
+export declare const reconcileContextUsageFromEvent: (snapshot: TContextUsageEvent, event: TTokenUsageEvent) => TContextUsageEvent;
 /** Lifecycle phase carried on subagent-progress envelopes (mirrors SDK SubagentUpdatePhase). */
 export type SubagentUpdatePhase = 'start' | 'run_step' | 'run_step_delta' | 'run_step_completed' | 'run_step_closed' | 'message_delta' | 'reasoning_delta' | 'stop' | 'error';
 /** Structured root-to-leaf identity for one nested subagent execution. */
@@ -331,6 +358,7 @@ export interface SubagentAncestryEntry {
     readonly parentAgentId?: string;
     readonly parentToolCallId?: string;
 }
+export type SubagentIdentity = Pick<SubagentAncestryEntry, 'subagentKind' | 'subagentAgentId'>;
 /** Single streamed subagent update forwarded by the SDK's SubagentExecutor. */
 export interface SubagentUpdateEvent {
     runId: string;

package/dist/types/types/schedules.d.ts

@@ -9,7 +9,7 @@ export type ScheduleFrequency = (typeof scheduleFrequencies)[number];
 export declare const SCHEDULE_CRON_MAX_LENGTH = 256;
 export declare const scheduleTargets: readonly ["new"];
 export type ScheduleTarget = (typeof scheduleTargets)[number];
-export type ScheduleDisabledReason = 'too_many_failures' | 'agent_deleted' | 'invalid_schedule' | 'permission_revoked' | 'insufficient_balance' | 'project_deleted' | 'project_required';
+export type ScheduleDisabledReason = 'mcp_reauth_required' | 'mcp_configuration_missing' | 'mcp_permission_denied' | 'too_many_failures' | 'agent_deleted' | 'invalid_schedule' | 'permission_revoked' | 'insufficient_balance' | 'project_deleted' | 'project_required';
 export type ScheduleRunStatus = 'started' | 'requires_action' | 'success' | 'error' | 'interrupted' | 'skipped_overlap' | 'skipped_balance';
 export declare const structuredCadenceSchema: z.ZodObject<{
     frequency: z.ZodEnum<["hourly", "daily", "weekdays", "weekly"]>;
@@ -123,9 +123,9 @@ export declare const createSchedulePayloadSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     name: string;
     agent_id: string;
-    clientRequestId: string;
-    prompt: string;
     enabled: boolean;
+    prompt: string;
+    clientRequestId: string;
     timezone: string;
     cadence: {
         frequency: "hourly" | "daily" | "weekdays" | "weekly";
@@ -142,8 +142,8 @@ export declare const createSchedulePayloadSchema: z.ZodObject<{
 }, {
     name: string;
     agent_id: string;
-    clientRequestId: string;
     prompt: string;
+    clientRequestId: string;
     timezone: string;
     cadence: {
         frequency: "hourly" | "daily" | "weekdays" | "weekly";
@@ -166,8 +166,8 @@ export declare const updateSchedulePayloadSchema: z.ZodObject<{
     chatProjectId: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
     file_ids: z.ZodOptional<z.ZodOptional<z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>>>;
     agent_id: z.ZodOptional<z.ZodString>;
-    prompt: z.ZodOptional<z.ZodString>;
     enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    prompt: z.ZodOptional<z.ZodString>;
     timezone: z.ZodOptional<z.ZodString>;
     cadence: z.ZodOptional<z.ZodDiscriminatedUnion<"frequency", [z.ZodObject<{
         frequency: z.ZodEnum<["hourly", "daily", "weekdays", "weekly"]>;
@@ -209,8 +209,8 @@ export declare const updateSchedulePayloadSchema: z.ZodObject<{
     chatProjectId?: string | null | undefined;
     file_ids?: string[] | undefined;
     agent_id?: string | undefined;
-    prompt?: string | undefined;
     enabled?: boolean | undefined;
+    prompt?: string | undefined;
     timezone?: string | undefined;
     cadence?: {
         frequency: "hourly" | "daily" | "weekdays" | "weekly";
@@ -228,8 +228,8 @@ export declare const updateSchedulePayloadSchema: z.ZodObject<{
     chatProjectId?: string | null | undefined;
     file_ids?: string[] | undefined;
     agent_id?: string | undefined;
-    prompt?: string | undefined;
     enabled?: boolean | undefined;
+    prompt?: string | undefined;
     timezone?: string | undefined;
     cadence?: {
         frequency: "hourly" | "daily" | "weekdays" | "weekly";
@@ -248,6 +248,7 @@ export type TScheduleLastRun = {
     conversationId?: string;
     status: ScheduleRunStatus;
     error?: string;
+    mcp?: ScheduleMCPOutcome[];
     firedAt: string;
 };
 export type TSchedule = {
@@ -265,6 +266,17 @@ export type TSchedule = {
     disabledReason?: ScheduleDisabledReason;
     nextRunAt?: string;
     lastRun?: TScheduleLastRun;
+    /**
+     * The occurrences generating right now. Read from their own run rows, not from
+     * `lastRun`, which is projected only when a run settles, pauses or skips and is
+     * deliberately withheld from a run whose schedule was edited mid-flight. This is
+     * the signal a client has that a chat is on its way, and the id to fetch it by.
+     * A run parked on an approval is not here: its chat was listed long ago, and the
+     * rows can accumulate for as long as approvals wait.
+     */
+    inFlight?: Array<{
+        conversationId: string;
+    }>;
     runCount: number;
     failureCount: number;
     configRevision?: number;
@@ -272,6 +284,7 @@ export type TSchedule = {
     updatedAt: string;
 };
 export type TScheduleRun = {
+    mcp?: ScheduleMCPOutcome[];
     scheduleId: string;
     scheduledFor: string;
     firedAt?: string;
@@ -304,3 +317,23 @@ export type TScheduleRunNowResponse = {
     conversationId: string;
     status: 'started';
 };
+/** Only structured schedule preflight failures may request immediate suspension. */
+export declare function getScheduleMCPDisabledReason(outcomes?: ScheduleMCPOutcome[]): 'mcp_reauth_required' | 'mcp_configuration_missing' | 'mcp_permission_denied' | undefined;
+export declare const scheduleMCPOutcomeSchema: z.ZodObject<{
+    server: z.ZodString;
+    /** Agent whose selected tool requires this server. Used to open the correct
+     * recovery chat when the requirement belongs to a handoff or subagent. */
+    agentId: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<["ready", "mcp_reauth_required", "mcp_configuration_missing", "mcp_permission_denied", "mcp_unavailable"]>;
+}, "strip", z.ZodTypeAny, {
+    status: "ready" | "mcp_reauth_required" | "mcp_configuration_missing" | "mcp_permission_denied" | "mcp_unavailable";
+    server: string;
+    agentId?: string | undefined;
+}, {
+    status: "ready" | "mcp_reauth_required" | "mcp_configuration_missing" | "mcp_permission_denied" | "mcp_unavailable";
+    server: string;
+    agentId?: string | undefined;
+}>;
+export type ScheduleMCPOutcome = z.infer<typeof scheduleMCPOutcomeSchema>;
+export type ScheduleMCPStatus = ScheduleMCPOutcome['status'];
+export declare function readScheduleMCPOutcomes(error?: string): ScheduleMCPOutcome[];

package/dist/types/types/skills.d.ts

@@ -315,10 +315,53 @@ export type TSkillListResponse = {
     has_more: boolean;
     after: string | null;
 };
+/**
+ * Why one archive entry could not be imported. A stable code rather than a
+ * message, so the client localizes the reason and server-side storage and
+ * database text never reaches the uploader.
+ */
+export type SkillImportFailureReason = 
+/** Path is absolute, traverses, or uses characters skills cannot store. */
+'invalid_path'
+/** Entry alone exceeds the per-file decompression limit. */
+ | 'file_too_large'
+/** Archive exhausted the cumulative decompression budget at or before this entry. */
+ | 'archive_too_large'
+/** Entry no longer matches what content inspection read. */
+ | 'archive_entry_changed'
+/** Storage write or database row failed. */
+ | 'persistence_failed';
+/** One archive entry POST `/api/skills/import` could not persist. */
+export type TSkillImportFailedFile = {
+    /** Path inside the archive, relative to `SKILL.md`. */
+    path: string;
+    reason: SkillImportFailureReason;
+    /** Limit in MB, when `reason` names a size limit. */
+    limitMb?: number;
+};
+/**
+ * Response from a failed `POST /api/skills/import` of an archive.
+ *
+ * `skill_import_incomplete` (422) means at least one bundled file failed and
+ * everything the import created was rolled back. `skill_import_rollback_failed`
+ * (500) means the same failure occurred but the partially created skill could
+ * not be removed, so it may still be listed and needs deleting by hand.
+ * `skill_import_cleanup_incomplete` (500) means the Skill row was removed but
+ * dependent database or blob cleanup did not finish.
+ */
+export type TSkillImportFailedResponse = {
+    error: 'skill_import_incomplete' | 'skill_import_rollback_failed' | 'skill_import_cleanup_incomplete';
+    message: string;
+    failedFiles: TSkillImportFailedFile[];
+    /** Present when the Skill row may remain and should be surfaced for deletion. */
+    skillId?: string;
+};
 /** Response from DELETE `/api/skills/:id`. */
 export type TDeleteSkillResponse = {
     id: string;
     deleted: true;
+    /** False when the Skill row is gone but a dependent cleanup step needs repair. */
+    cleanupComplete?: boolean;
 };
 /** Response from GET `/api/skills/:id/files`. */
 export type TListSkillFilesResponse = {

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

@@ -0,0 +1,132 @@
+import type { OpenAPIV3 } from 'openapi-types';
+export type Schema = OpenAPIV3.SchemaObject & {
+    description?: string;
+};
+export type Reference = OpenAPIV3.ReferenceObject & {
+    description?: string;
+};
+export declare enum Tools {
+    execute_code = "execute_code",
+    code_interpreter = "code_interpreter",
+    file_search = "file_search",
+    web_search = "web_search",
+    retrieval = "retrieval",
+    function = "function",
+    memory = "memory",
+    ui_resources = "ui_resources",
+    skill = "skill",
+    read_file = "read_file",
+    bash_tool = "bash_tool"
+}
+export declare enum EToolResources {
+    code_interpreter = "code_interpreter",
+    execute_code = "execute_code",
+    file_search = "file_search",
+    image_edit = "image_edit",
+    context = "context",
+    ocr = "ocr"
+}
+export type Tool = {
+    [type: string]: Tools;
+};
+export type FunctionTool = {
+    type: Tools;
+    function?: {
+        description: string;
+        name: string;
+        parameters: Record<string, unknown>;
+        strict?: boolean;
+        additionalProperties?: boolean;
+    };
+};
+/**
+ * A set of resources that are used by the assistant's tools. The resources are
+ * specific to the type of tool. For example, the `code_interpreter` tool requires
+ * a list of file IDs, while the `file_search` tool requires a list of vector store
+ * IDs.
+ */
+export interface ToolResources {
+    code_interpreter?: CodeInterpreterResource;
+    file_search?: FileSearchResource;
+}
+export interface CodeInterpreterResource {
+    /**
+     * A list of [file](https://platform.openai.com/docs/api-reference/files) IDs made
+     * available to the `code_interpreter`` tool. There can be a maximum of 20 files
+     * associated with the tool.
+     */
+    file_ids?: Array<string>;
+}
+export interface FileSearchResource {
+    /**
+     * The ID of the
+     * [vector store](https://platform.openai.com/docs/api-reference/vector-stores/object)
+     * attached to this assistant. There can be a maximum of 1 vector store attached to
+     * the assistant.
+     */
+    vector_store_ids?: Array<string>;
+}
+/**
+ * Specifies who can invoke a tool.
+ * - 'direct': LLM can call directly
+ * - 'code_execution': Only callable via programmatic tool calling (PTC)
+ */
+export type AllowedCaller = 'direct' | 'code_execution';
+/**
+ * Per-tool configuration options stored at the agent level.
+ * Keyed by tool_id (e.g., "search_mcp_github").
+ */
+export type ToolOptions = {
+    /**
+     * If true, the tool uses deferred loading (discoverable via tool search).
+     * @default false
+     */
+    defer_loading?: boolean;
+    /**
+     * Specifies who can invoke this tool.
+     * - 'direct': LLM can call directly (default behavior)
+     * - 'code_execution': Only callable via PTC sandbox
+     * @default ['direct']
+     */
+    allowed_callers?: AllowedCaller[];
+    /**
+     * If true (and the `run_in_background` capability is enabled), the tool's
+     * schema gains a `run_in_background` boolean so the model can dispatch the
+     * call detached and poll its result via `check_background_task`.
+     * @default false
+     */
+    run_in_background?: boolean;
+    /**
+     * If true (and the `tool_intents` capability is enabled), the tool's schema
+     * gains an `intent` string as its FIRST property — one model-authored
+     * sentence per call, rendered as the call's live status label. Native host
+     * tools default on while the capability is enabled; `false` opts one out.
+     * @default false
+     */
+    describe_intent?: boolean;
+};
+/**
+ * Map of tool_id to its configuration options.
+ * Used to customize tool behavior per agent.
+ */
+export type AgentToolOptions = Record<string, ToolOptions>;
+export declare const actionDelimiter = "_action_";
+export declare const actionDomainSeparator = "---";
+/**
+ * Checks whether a tool name is an OpenAPI action tool.
+ *
+ * Action format: `operationId_action_normalizedDomain`
+ * MCP format:    `toolName_mcp_serverName`
+ *
+ * Cross-delimiter collision: an MCP tool like `get_action_mcp_srv` contains
+ * `_action_` as a false positive. Guarded by checking whether `_mcp_` appears
+ * after `_action_`. In the collision case the `_mcp_` suffix always follows
+ * `_action_`; in a valid action tool whose operationId contains `_mcp_`, the
+ * `_mcp_` precedes `_action_`.
+ *
+ * Theoretical limitation: a non-RFC-compliant domain containing literal
+ * underscores that form `_mcp_` (e.g. `api_mcp_internal.com`) would produce
+ * a false negative. RFC 952/1123 prohibit underscores in hostnames, so this
+ * is not expected in practice.
+ */
+export declare function isActionTool(toolName: string): boolean;

package/dist/types/types/traces.d.ts

@@ -0,0 +1,134 @@
+/**
+ * Provider-neutral conversation trace contract. The server maps whatever its
+ * tracing backend stores into these shapes, so the client never sees a
+ * backend's field names, credentials, URL structure or API version.
+ */
+export type TTraceRecordKind = 'agent' | 'generation' | 'tool' | 'span' | 'event';
+/**
+ * What a record did in the run, in the application's own terms, so a client never reads a tracing
+ * backend's span names. Absent on a record the backend did not describe: it is listed by `kind`.
+ * `run` is a whole agent run, `agent` the named agent inside it, `plumbing` a wrapper that only
+ * frames a model call, `model` a model call of the response, `tools` one round of tool calls, and
+ * the label roles are the model calls that wrote the activity labels the chat shows while a
+ * response runs.
+ */
+export type TTraceRecordRole = 'run' | 'agent' | 'plumbing' | 'model' | 'tools' | 'stepLabel' | 'reasoningLabel' | 'phaseLabel';
+/** `running` marks a record with no end time yet; it has a start but no duration. */
+export type TTraceStatus = 'ok' | 'warning' | 'error' | 'running';
+export type TTraceUsage = {
+    input?: number;
+    output?: number;
+    total?: number;
+    reasoning?: number;
+    cacheRead?: number;
+    cacheWrite?: number;
+};
+export type TTraceRecord = {
+    id: string;
+    traceId: string;
+    /** The response message whose turn produced this record; groups records into turns. */
+    messageId: string;
+    /** `null` for a root; may name a record that is not loaded (or does not exist). */
+    parentId: string | null;
+    kind: TTraceRecordKind;
+    role?: TTraceRecordRole;
+    /** The saved agent a `role: 'agent'` record ran; absent for an agent that was never saved. */
+    agentId?: string;
+    /** The tools a `role: 'tools'` round called, in order, as the backend recorded the round. */
+    tools?: string[];
+    name: string;
+    model?: string;
+    /** ISO-8601 timestamps. */
+    startTime: string;
+    endTime?: string;
+    /** First streamed token of a generation; splits its span into TTFT and decoding. */
+    completionStartTime?: string;
+    status: TTraceStatus;
+    statusMessage?: string;
+    usage?: TTraceUsage;
+    /** Total cost in USD, when the backend priced the record. */
+    cost?: number;
+    /** Set on records of the turn's title generation; absent on the response run itself. */
+    origin?: 'title';
+};
+export type TTraceErrorCode = 'disabled' | 'not_found' | 'invalid_request' | 'rate_limited' | 'timeout' | 'unauthorized' | 'unsupported' | 'upstream_error';
+export type TTraceErrorResponse = {
+    error: string;
+    errorCode: TTraceErrorCode;
+};
+export type TTraceAvailability = {
+    available: boolean;
+    /** Set when the backend cannot decide yet; ask again after this many milliseconds. */
+    retryAfterMs?: number;
+};
+export type TTracePageParams = {
+    conversationId: string;
+    cursor?: string;
+};
+export type TTraceRecordParams = {
+    conversationId: string;
+    recordId: string;
+    /** The turn the list attributed the record to; its traces are what authorize the read. */
+    messageId: string;
+    /** The `sourceId` of the page that listed the record, so its detail reads the same project. */
+    sourceId?: string;
+};
+/**
+ * Newest turns first; `nextCursor` loads the next older page. A turn's records
+ * may continue on the following page, and their order within a turn is not
+ * defined, so a client groups records by turn and orders them by time.
+ */
+export type TTracePage = {
+    records: TTraceRecord[];
+    nextCursor?: string;
+    /** Opaque identity of the backend project that served the page. */
+    sourceId?: string;
+};
+export type TTraceContent = {
+    value: string;
+    truncated: boolean;
+};
+export type TTraceMessageRole = 'system' | 'user' | 'assistant' | 'tool';
+export type TTraceToolCall = {
+    name: string;
+    args?: TTraceContent;
+};
+/** One message of a model call's conversation, each bounded on its own so a long one hides no other. */
+export type TTraceMessage = {
+    role: TTraceMessageRole;
+    text?: TTraceContent;
+    /** The tool a `tool` message answers for. */
+    toolName?: string;
+    /** The tools an `assistant` message asked for. */
+    toolCalls?: TTraceToolCall[];
+    /** Parts that are not text (an image, a file), by their type. */
+    attachments?: string[];
+};
+/**
+ * What a model call was given, as a conversation. A long one keeps its system
+ * message and its newest messages, which are what the call answered, and
+ * `omitted` counts the older ones left out between them.
+ */
+export type TTracePrompt = {
+    messages: TTraceMessage[];
+    /** Every message the call was given, listed or not. */
+    total: number;
+    omitted: number;
+    /** Names of the tools the model could call. */
+    tools?: string[];
+};
+export type TTraceRecordDetail = {
+    record: TTraceRecord;
+    /** False when the deployment withholds input, output and metadata. */
+    contentAvailable: boolean;
+    /** Set when the input is a conversation the backend could read as one; `input` stays the raw form. */
+    prompt?: TTracePrompt;
+    /** Set when the output is a message the backend could read as one; `output` stays the raw form. */
+    reply?: TTraceMessage;
+    input?: TTraceContent;
+    output?: TTraceContent;
+    metadata?: TTraceContent;
+};
+export declare const TRACE_CURSOR_MAX_LENGTH = 4096;
+export declare const TRACE_SOURCE_ID_MAX_LENGTH = 128;
+export declare const TRACE_RECORD_ID_MAX_LENGTH = 256;

package/dist/types/types.d.ts

@@ -1,12 +1,16 @@
 import type { InfiniteData } from '@tanstack/react-query';
 import type { TConversationTag, EModelEndpoint, TConversation, TSharedLink, TAttachment, TMessage, TBanner, ReasoningResponseKey, ReasoningParameterFormat } from './schemas';
-import type { CodeEnvironmentUserConfigSchema, CodeEnvironmentUserSettings } from './config';
-import type { Agent, EToolResources, StatefulCodeEnvironment } from './types/assistants';
+import type { CodeWorkspaceDescriptor, CodeEnvironmentMode, CodeWorkspaceOperation, CodeWorkspaceSelection } from './code/workspace';
+import type { CodeEnvironmentUserConfigSchema, CodeEnvironmentUserSettings, TAgentsEndpoint } from './config';
+import type { StatefulCodeEnvironment } from './stateful-code';
+import type { CodeApprovalMode } from './code/approval';
+import type { EToolResources } from './types/tools';
 import type { RefillIntervalUnit } from './balance';
 import type { SettingDefinition } from './generate';
 import type { TMinimalFeedback } from './feedback';
 import type { ContentTypes } from './types/runs';
 import type { ProviderId } from './providers';
+import type { Agent } from './types/agents';
 export * from './schemas';
 export * from './types/subagents';
 export type TMessages = TMessage[];
@@ -51,6 +55,9 @@ export type TEphemeralAgent = {
 export type TPayload = Partial<TMessage> & Partial<TEndpointOption> & {
     isContinued: boolean;
     isRegenerate?: boolean;
+    /** Manual context compaction: summarize the branch up to `parentMessageId`
+     *  and end without a reply. No user message is created. */
+    compact?: boolean;
     conversationId: string | null;
     messages?: TMessages;
     isTemporary: boolean;
@@ -65,6 +72,12 @@ export type TPayload = Partial<TMessage> & Partial<TEndpointOption> & {
      * before the LLM turn runs.
      */
     manualSkills?: string[];
+    /** Conversation-scoped preference for code tool approval behavior. */
+    codeApprovalMode?: CodeApprovalMode;
+    /** Immutable conversation choice for attached code execution. */
+    codeEnvironmentMode?: CodeEnvironmentMode;
+    /** Conversation-selected workspaces, with at most one binding per environment. */
+    codeWorkspaces?: CodeWorkspaceSelection[];
     /** Browser IANA timezone (e.g. `America/New_York`) used to resolve local-time prompt variables server-side. */
     timezone?: string;
     /**
@@ -101,6 +114,9 @@ export type TSubmission = {
     /** Client-only full message context used to restore branch siblings after scoped regenerate. */
     regenerateMessages?: TMessage[];
     isRegenerate?: boolean;
+    /** Manual context compaction; shaped like a regenerate on the client (no new
+     *  user bubble) and sent to the server as a summarize-only turn. */
+    compact?: boolean;
     initialResponse?: TMessage;
     conversation: Partial<TConversation>;
     endpointOption: TEndpointOption;
@@ -137,6 +153,12 @@ export type TSubmission = {
     addedConvo?: TConversation;
     /** Skills the user invoked via the `$` popover for this submission. */
     manualSkills?: string[];
+    /** Conversation-scoped preference for code tool approval behavior. */
+    codeApprovalMode?: CodeApprovalMode;
+    /** Immutable conversation choice for attached code execution. */
+    codeEnvironmentMode?: CodeEnvironmentMode;
+    /** Conversation-selected workspaces, with at most one binding per environment. */
+    codeWorkspaces?: CodeWorkspaceSelection[];
     /** Stable per-submission idempotency key (uuid) forwarded to the server to dedup retried start-generation requests. */
     clientRequestId?: string;
     /** Client-only carry-through for a receipt-bound queued recovery. */
@@ -327,6 +349,9 @@ export type TPinConversationResponse = TConversation;
 export type TSharedMessagesResponse = Omit<TSharedLink, 'messages'> & {
     messages: TMessage[];
     langfuseSessionUrl?: string;
+    /** Whether the link was published with a configured sender label; withholds the
+     * model on hover. */
+    hasConfiguredSender?: boolean;
 };
 export type TCreateShareLinkRequest = Pick<TConversation, 'conversationId'>;
 export type TUpdateShareLinkRequest = Pick<TSharedLink, 'shareId' | 'targetMessageId'>;
@@ -424,7 +449,42 @@ export type TCodeEnvironmentPairingResponse = {
         endpoint: string;
     };
 };
+export type TCodeEnvironmentStatusResponse = {
+    environmentId: string;
+    status: 'offline' | 'starting' | 'ready';
+    statefulWorkspace?: boolean;
+    leaseExpiresInMs?: number;
+    sandboxProfile?: string;
+    runtimes?: string[];
+    operations?: CodeWorkspaceOperation[];
+    workspaces?: CodeWorkspaceDescriptor[];
+};
+/** Moves a sealed attached decision onto the environments a conversation's agents now use. */
+export type TCodeEnvironmentMoveRequest = {
+    conversationId: string;
+    /** The persisted selections being replaced; a mismatch rejects the move as stale. */
+    from: CodeWorkspaceSelection[];
+    to: CodeWorkspaceSelection[];
+};
+export type TCodeEnvironmentMoveResponse = {
+    conversationId: string;
+    codeEnvironmentMode: 'attached';
+    codeWorkspaces: CodeWorkspaceSelection[];
+};
+/** Sanitized results of server request shaping for each saved toggle state. */
+export type ResponsesApiRoute = {
+    default: boolean;
+    on: boolean;
+    off: boolean;
+    withWebSearch?: {
+        default: boolean;
+        on: boolean;
+        off: boolean;
+    };
+};
+export type ResponsesApiRouting = Record<string, ResponsesApiRoute>;
 export type TConfig = {
+    responsesApiRouting?: ResponsesApiRouting;
     order: number;
     type?: EModelEndpoint;
     azure?: boolean;
@@ -450,9 +510,17 @@ export type TConfig = {
     statefulCodeSessions?: {
         allowedEnvironments: StatefulCodeEnvironment[];
         environments?: TPublicCodeEnvironment[];
+        approvalsEnabled?: boolean;
+        /** Approval modes the endpoint policy permits the client to offer. */
+        approvalModes?: CodeApprovalMode[];
     };
     /** Effective subagents-per-agent cap served from `endpoints.agents.maxSubagents`. */
     maxSubagents?: number;
+    fileSharing?: TAgentsEndpoint['fileSharing'];
+    /** Concurrent Code API uploads allowed per route and authenticated principal. */
+    codeApiUploadConcurrency?: number;
+    /** Milliseconds one operation may spend waiting on Code API rate limits. */
+    codeApiMaxRetryWaitMs?: number;
     customParams?: {
         defaultParamsEndpoint?: string;
         reasoningFormat?: ReasoningParameterFormat;
@@ -793,4 +861,6 @@ export type TLangfuseConnectionTestResponse = {
 };
 export type TLangfuseSessionLinkResponse = {
     url: string | null;
+    /** Opaque identity of the project `url` opens, so a caller can tell whether it holds what it showed. */
+    destinationId?: string;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "librechat-data-provider",
-  "version": "0.8.522",
+  "version": "0.8.524",
   "description": "data services for librechat apps",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -46,7 +46,7 @@
     "axios": "^1.20.0",
     "croner": "^10.0.1",
     "dayjs": "^1.11.13",
-    "js-yaml": "^4.3.1",
+    "js-yaml": "^4.3.2",
     "re2js": "^2.8.6",
     "zod": "^3.22.4"
   },