librechat-data-provider 0.8.522 → 0.8.523

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"]>;
@@ -122,10 +122,10 @@ export declare const createSchedulePayloadSchema: z.ZodObject<{
     clientRequestId: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     name: string;
-    agent_id: string;
-    clientRequestId: string;
     prompt: string;
     enabled: boolean;
+    agent_id: string;
+    clientRequestId: string;
     timezone: string;
     cadence: {
         frequency: "hourly" | "daily" | "weekdays" | "weekly";
@@ -141,9 +141,9 @@ export declare const createSchedulePayloadSchema: z.ZodObject<{
     file_ids?: string[] | undefined;
 }, {
     name: string;
+    prompt: string;
     agent_id: string;
     clientRequestId: string;
-    prompt: string;
     timezone: string;
     cadence: {
         frequency: "hourly" | "daily" | "weekdays" | "weekly";
@@ -154,20 +154,20 @@ export declare const createSchedulePayloadSchema: z.ZodObject<{
         frequency: "cron";
         expression: string;
     };
+    enabled?: boolean | undefined;
     chatProjectId?: string | null | undefined;
     file_ids?: string[] | undefined;
-    enabled?: boolean | undefined;
     target?: "new" | undefined;
 }>;
 export type TCreateSchedule = z.infer<typeof createSchedulePayloadSchema>;
 /** Idempotency is a property of the CREATE attempt, not of the schedule's config. */
 export declare const updateSchedulePayloadSchema: z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
+    prompt: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
     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>>;
     timezone: z.ZodOptional<z.ZodString>;
     cadence: z.ZodOptional<z.ZodDiscriminatedUnion<"frequency", [z.ZodObject<{
         frequency: z.ZodEnum<["hourly", "daily", "weekdays", "weekly"]>;
@@ -206,11 +206,11 @@ export declare const updateSchedulePayloadSchema: z.ZodObject<{
     expectedConfigRevision: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     name?: string | undefined;
+    prompt?: string | undefined;
+    enabled?: boolean | undefined;
     chatProjectId?: string | null | undefined;
     file_ids?: string[] | undefined;
     agent_id?: string | undefined;
-    prompt?: string | undefined;
-    enabled?: boolean | undefined;
     timezone?: string | undefined;
     cadence?: {
         frequency: "hourly" | "daily" | "weekdays" | "weekly";
@@ -225,11 +225,11 @@ export declare const updateSchedulePayloadSchema: z.ZodObject<{
     expectedConfigRevision?: number | undefined;
 }, {
     name?: string | undefined;
+    prompt?: string | undefined;
+    enabled?: boolean | undefined;
     chatProjectId?: string | null | undefined;
     file_ids?: string[] | undefined;
     agent_id?: string | undefined;
-    prompt?: string | undefined;
-    enabled?: boolean | 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/traces.d.ts

@@ -0,0 +1,85 @@
+/**
+ * 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';
+/** `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;
+    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;
+};
+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 TTraceRecordDetail = {
+    record: TTraceRecord;
+    /** False when the deployment withholds input, output and metadata. */
+    contentAvailable: boolean;
+    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,7 +1,9 @@
 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 { CodeWorkspaceDescriptor, CodeEnvironmentMode, CodeWorkspaceOperation, CodeWorkspaceSelection } from './code/workspace';
+import type { CodeEnvironmentUserConfigSchema, CodeEnvironmentUserSettings, TAgentsEndpoint } from './config';
 import type { Agent, EToolResources, StatefulCodeEnvironment } from './types/assistants';
+import type { CodeApprovalMode } from './code/approval';
 import type { RefillIntervalUnit } from './balance';
 import type { SettingDefinition } from './generate';
 import type { TMinimalFeedback } from './feedback';
@@ -51,6 +53,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 +70,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 +112,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 +151,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. */
@@ -424,6 +444,16 @@ 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[];
+};
 export type TConfig = {
     order: number;
     type?: EModelEndpoint;
@@ -450,9 +480,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 +831,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.523",
   "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"
   },