librechat-data-provider 0.8.508 → 0.8.521

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

@@ -1,3 +1,4 @@
+import type { TFile } from './files';
 export declare enum ContentTypes {
     TEXT = "text",
     THINK = "think",
@@ -9,6 +10,8 @@ export declare enum ContentTypes {
     INPUT_AUDIO = "input_audio",
     AGENT_UPDATE = "agent_update",
     SUMMARY = "summary",
+    ACTIVITY_LABEL = "activity_label",
+    STEER = "steer",
     ERROR = "error"
 }
 export declare enum StepTypes {
@@ -33,13 +36,120 @@ export declare enum StepEvents {
     ON_SUMMARIZE_START = "on_summarize_start",
     ON_SUMMARIZE_DELTA = "on_summarize_delta",
     ON_SUMMARIZE_COMPLETE = "on_summarize_complete",
-    ON_SUBAGENT_UPDATE = "on_subagent_update"
+    ON_SUBAGENT_UPDATE = "on_subagent_update",
+    ON_SANDBOX_STARTING = "on_sandbox_starting"
 }
+/** Payload for {@link StepEvents.ON_SANDBOX_STARTING} — the stateful code
+ * sandbox is cold-booting for the given code tool call. */
+export type SandboxStartingEvent = {
+    tool_call_id: string;
+    runId?: string;
+};
 /** Token-tracking event names streamed to the client (separate from StepEvents dispatch). */
 export declare enum UsageEvents {
     ON_CONTEXT_USAGE = "on_context_usage",
     ON_TOKEN_USAGE = "on_token_usage"
 }
+/**
+ * Human-in-the-loop event names. Streamed to live clients when a run pauses for
+ * tool approval (or an ask-user question). Reconnecting clients instead read the
+ * same record from `resumeState.pendingAction` on the sync event / status route.
+ */
+export declare enum ApprovalEvents {
+    ON_PENDING_ACTION = "on_pending_action"
+}
+/**
+ * Steering event names. `on_steer_applied` streams to live clients when a
+ * queued steer message is injected at a tool-batch boundary; reconnecting
+ * clients recover injected steers from `aggregatedContent` and still-queued
+ * ones from `resumeState.pendingSteers`. Steers that never reach a boundary
+ * ride the final/abort events as `pendingSteers`.
+ */
+export declare enum SteerEvents {
+    ON_STEER_APPLIED = "on_steer_applied",
+    /** Durable capability correction for queued steers after HITL handover. */
+    ON_STEER_UPDATED = "on_steer_updated"
+}
+/**
+ * Activity-label event names. `on_activity_label` streams to live clients
+ * when a tool-batch or parent-phase label part is claimed and again when the
+ * fast-model label resolves; reconnecting clients recover applied labels
+ * from `aggregatedContent` like any other content part.
+ */
+export declare enum ActivityLabelEvents {
+    ON_ACTIVITY_LABEL = "on_activity_label"
+}
+/** Payload of the `on_activity_label` SSE event. */
+export type TActivityLabelEvent = {
+    /** Absolute content index the label part occupies. */
+    index: number;
+    part: {
+        type: ContentTypes.ACTIVITY_LABEL;
+        [ContentTypes.ACTIVITY_LABEL]: string;
+        /** Missing means a per-batch activity label. */
+        activity_label_type?: 'phase';
+        tool_call_ids?: string[];
+        activity_start_index?: number;
+        activity_end_index?: number;
+        activity_count?: number;
+        agent_ids?: string[];
+        counts?: {
+            searches: number;
+            reads: number;
+            writes: number;
+            commands: number;
+            other: number;
+        };
+        status?: 'ok' | 'partial' | 'failed';
+        agentId?: string;
+        pending?: boolean;
+    };
+    responseMessageId?: string;
+    conversationId?: string;
+};
+/** A steer message queued server-side but not yet injected into the run. */
+export type TPendingSteer = {
+    steerId: string;
+    /** Correlates a server steer with its optimistic chip when terminal delivery
+     *  races ahead of the POST response. */
+    clientSteerId?: string;
+    text: string;
+    createdAt?: number;
+    files?: Partial<TFile>[];
+    /** The steer asked to interrupt generation at the next safe boundary —
+     *  kept on parked/replayed chips so the "interrupting" label survives. */
+    preempt?: boolean;
+    /** Monotonic server revision for last-writer-wins interrupt labels. */
+    preemptRevision?: number;
+};
+/** Payload of the `on_steer_applied` SSE event. */
+export type TSteerAppliedEvent = {
+    steerId: string;
+    /** Correlates the applied event with the optimistic chip before the POST settles. */
+    clientSteerId?: string;
+    /** Absolute content index the steer part was injected at. */
+    index: number;
+    part: {
+        type: ContentTypes.STEER;
+        [ContentTypes.STEER]: string;
+        steerId?: string;
+        clientSteerId?: string;
+        createdAt?: number;
+        files?: Partial<TFile>[];
+    };
+    responseMessageId?: string;
+    conversationId?: string;
+};
+/** A queued steer's interrupt label changed without moving its FIFO slot. */
+export type TSteerUpdatedEvent = {
+    conversationId: string;
+    steers: Array<{
+        steerId: string;
+        clientSteerId?: string;
+        preempt: boolean;
+        preemptRevision: number;
+    }>;
+};
 /** Mirrors TokenBudgetBreakdown from @librechat/agents (data-provider cannot import it). */
 export type TTokenBudgetBreakdown = {
     maxContextTokens: number;
@@ -78,28 +188,6 @@ export type TContextUsageEvent = {
      *  already includes for earlier steps. */
     completedOutputTokens?: number;
 };
-/**
- * Request payload for a server-side context-usage projection: "what context
- * would the next call send for this branch under this config", computed by the
- * agents SDK without invoking the model. Powers the gauge in states the live
- * snapshot can't cover (page load of a snapshot-less branch, window/model
- * switch). `messageId` is the viewed branch's tail; the server walks its parent
- * chain.
- */
-export type TContextProjectionRequest = {
-    conversationId: string;
-    messageId: string;
-    endpoint: string;
-    model?: string;
-    agentId?: string;
-    spec?: string;
-    maxContextTokens?: number;
-    /** Provider-calibrated ratio from a prior snapshot, applied as a static seed. */
-    calibrationRatio?: number;
-    /** Client-only cache-bust: a branch content revision so a message edit
-     *  (which keeps the same tail id) refetches. The server ignores it. */
-    revision?: number;
-};
 /**
  * Per-response usage rollup persisted on `responseMessage.metadata.usage`, in
  * display units (input excludes cache; output includes repaired completion).
@@ -128,8 +216,9 @@ export type TTokenUsageEvent = {
     provider?: string;
     /** Non-primary buckets fold into session cost/totals but not the live
      *  context gauge: hidden sequential-agent calls (`sequential`), summary
-     *  passes (`summarization`), and isolated subagent runs (`subagent`) */
-    usage_type?: 'summarization' | 'subagent' | 'sequential';
+     *  passes (`summarization`), isolated subagent runs (`subagent`), and
+     *  fast-model activity headers (`activity-label`, `activity-phase`) */
+    usage_type?: 'summarization' | 'subagent' | 'sequential' | 'activity-label' | 'activity-phase';
     runId?: string;
     /** Per-run emission sequence; keeps identical payloads from distinct model calls unique */
     seq?: number;

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

@@ -33,11 +33,20 @@ export type SkillSource = 'inline' | 'deployment' | 'github' | 'notion';
  * everything else (including root-level files) is `other`.
  */
 export type SkillFileCategory = 'script' | 'reference' | 'asset' | 'other';
+/** Nested object inside a structured frontmatter key. */
+export type SkillFrontmatterObject = {
+    [key: string]: SkillFrontmatterValue | undefined;
+};
 /**
- * Allowed value types inside a skill's YAML frontmatter.
- * Kept strict so callers cannot slip arbitrary `unknown` payloads through the API.
+ * Allowed value types inside a skill's YAML frontmatter. Scalars cover the
+ * documented keys; nested arrays and objects describe the structured ones
+ * (`hooks`, `metadata`, `references`), which real `SKILL.md` files write as a
+ * list, a list of objects, or a map.
+ *
+ * Still no `unknown` or `any`: the payload is JSON-safe by construction, and
+ * the server bounds depth, string length and array size when validating it.
  */
-export type SkillFrontmatterValue = string | number | boolean | string[] | null;
+export type SkillFrontmatterValue = string | number | boolean | null | SkillFrontmatterValue[] | SkillFrontmatterObject;
 /**
  * Structured YAML frontmatter for a skill. All keys are optional on the wire
  * because not every skill document carries a complete frontmatter block —
@@ -95,8 +104,8 @@ export type TSkillWarning = {
  * - `description` is the "when to use this skill" sentence. Highest-leverage
  *   field for trigger accuracy; a short/vague one causes undertriggering.
  * - `frontmatter` is the structured YAML bag minus `name`/`description`
- *   (those live as top-level columns). Validated strictly against a known
- *   key set server-side.
+ *   (those live as top-level columns). Known keys receive value validation;
+ *   unknown keys are retained and reported as non-blocking warnings.
  * - `source`/`sourceMetadata` identify whether the row is user-authored,
  *   deployment-provided, or mirrored from an external source such as GitHub.
  */
@@ -200,11 +209,19 @@ export type TGitHubSkillSyncCredentialSummary = {
     updatedAt?: string;
     createdAt?: string;
 };
+/** One upstream skill a sync run dropped, with the reason it was dropped. */
+export type TGitHubSkillSyncSkippedSkill = {
+    path: string;
+    name?: string;
+    errorCode: string;
+    errorMessage: string;
+};
 export type TGitHubSkillSyncSourceStatus = {
     provider: 'github';
     sourceId: string;
     tenantId?: string;
-    status: 'idle' | 'running' | 'succeeded' | 'failed' | 'skipped';
+    /** `partial`: some skills published, others were skipped (see `skippedSkills`). */
+    status: 'idle' | 'running' | 'succeeded' | 'partial' | 'failed' | 'skipped';
     credentialKey?: string;
     credentialPresent: boolean;
     owner?: string;
@@ -221,6 +238,8 @@ export type TGitHubSkillSyncSourceStatus = {
     syncedFileCount: number;
     deletedSkillCount: number;
     deletedFileCount: number;
+    skippedSkillCount: number;
+    skippedSkills?: TGitHubSkillSyncSkippedSkill[];
     updatedAt?: string;
     createdAt?: string;
 };

package/dist/types/types.d.ts

@@ -1,10 +1,10 @@
 import type { InfiniteData } from '@tanstack/react-query';
 import type { TConversationTag, EModelEndpoint, TConversation, TSharedLink, TAttachment, TMessage, TBanner, ReasoningResponseKey, ReasoningParameterFormat } from './schemas';
+import type { Agent, EToolResources } from './types/assistants';
 import type { RefillIntervalUnit } from './balance';
 import type { SettingDefinition } from './generate';
 import type { TMinimalFeedback } from './feedback';
 import type { ContentTypes } from './types/runs';
-import type { Agent } from './types/assistants';
 export * from './schemas';
 export type TMessages = TMessage[];
 export type TEndpointOption = Pick<TConversation, 'endpoint' | 'endpointType' | 'model' | 'modelLabel' | 'chatGptLabel' | 'promptPrefix' | 'temperature' | 'topP' | 'topK' | 'top_p' | 'frequency_penalty' | 'presence_penalty' | 'maxOutputTokens' | 'maxContextTokens' | 'max_tokens' | 'maxTokens' | 'resendFiles' | 'imageDetail' | 'reasoning_effort' | 'verbosity' | 'instructions' | 'additional_instructions' | 'append_current_datetime' | 'tools' | 'stop' | 'region' | 'additionalModelRequestFields' | 'promptCache' | 'promptCacheTtl' | 'thinking' | 'thinkingBudget' | 'thinkingLevel' | 'effort' | 'thinkingDisplay' | 'assistant_id' | 'agent_id' | 'iconURL' | 'greeting' | 'spec' | 'artifacts' | 'file_ids' | 'system' | 'chatProjectId' | 'examples' | 'context'> & {
@@ -29,6 +29,21 @@ export type TEphemeralAgent = {
     execute_code?: boolean;
     artifacts?: string;
     skills?: boolean;
+    memory?: boolean;
+    /** Equip the ephemeral agent with the `ask_user_question` HITL tool. */
+    ask_user_question?: boolean;
+    /**
+     * Let the model dispatch this ephemeral agent's eligible tool calls in the
+     * background (poll results via `check_background_task`). Requires the
+     * `run_in_background` agent capability to be enabled by the admin.
+     */
+    run_in_background?: boolean;
+    /**
+     * Inject the `intent` label param into this ephemeral agent's eligible
+     * tools so each call streams a live status label. Requires the
+     * `tool_intents` agent capability to be enabled by the admin.
+     */
+    describe_intent?: boolean;
 };
 export type TPayload = Partial<TMessage> & Partial<TEndpointOption> & {
     isContinued: boolean;
@@ -49,6 +64,21 @@ export type TPayload = Partial<TMessage> & Partial<TEndpointOption> & {
     manualSkills?: string[];
     /** Browser IANA timezone (e.g. `America/New_York`) used to resolve local-time prompt variables server-side. */
     timezone?: string;
+    /**
+     * Stable per-submission idempotency key (uuid) generated once per `ask()`. Identical
+     * across the client's start-generation network retries, unique per user action (including
+     * regenerate). The server dedups retried start requests on it so a lost/reset response
+     * cannot trigger a second billed generation.
+     */
+    clientRequestId?: string;
+    /** Parked steer source consumed only after this new turn's user message is
+     * durably saved. Separate from `clientRequestId`, which identifies one
+     * generation attempt and must rotate after a failed recovery. */
+    recoverySteerId?: string;
+    /** Optional optimistic-serialization fence for a queued follow-up. The
+     * server may create only if this observed predecessor is still current or
+     * the conversation is still idle after its cleanup. */
+    expectedPredecessorCreatedAt?: number;
 };
 export type TEditedContent = {
     index: number;
@@ -74,10 +104,44 @@ export type TSubmission = {
     clientTimestamp?: string;
     ephemeralAgent?: TEphemeralAgent | null;
     editedContent?: TEditedContent | null;
+    /**
+     * Length of the retained content prefix for an edited resubmission, captured
+     * when the submission is built.
+     *
+     * The server indexes only NEW content, so the client offsets incoming
+     * indices by the prefix it kept. `initialResponse.content` cannot be used
+     * for that after a reconnect: the resume sync overwrites it with the
+     * server's completion-local snapshot, whose length is unrelated to the
+     * prefix. Recording the length up front keeps the offset stable across
+     * resumes for run steps and activity labels alike.
+     */
+    editPrefixLength?: number;
+    /** True once server index 0 text/reasoning actually merged into the retained tail. */
+    editPrefixFirstPartFolded?: boolean;
+    /**
+     * Set once a resume SYNC has replaced the response's retained prefix with
+     * the server's completion-local snapshot. From that point the prefix is
+     * gone from the rendered message and server indices are absolute in the
+     * new space, so {@link editPrefixLength} must NOT be applied — by run
+     * steps or by activity labels. Both event paths read this flag so a
+     * batch's tool cards and its header always land in one index space.
+     *
+     * Stamped per event by the resumable transport, which owns the SYNC
+     * boundary; the non-resumable path never sets it.
+     */
+    editPrefixCleared?: boolean;
     /** Added conversation for multi-convo feature */
     addedConvo?: TConversation;
     /** Skills the user invoked via the `$` popover for this submission. */
     manualSkills?: string[];
+    /** 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. */
+    recoverySteerId?: string;
+    expectedPredecessorCreatedAt?: number;
+    /** Opaque client-only queue restoration metadata; intentionally omitted by
+     * `createPayload`. */
+    queuedMessageOrigin?: unknown;
 };
 export type EventSubmission = Omit<TSubmission, 'initialResponse'> & {
     initialResponse: TMessage;
@@ -108,6 +172,8 @@ export type TMarketplaceCategory = TCategory & {
 export type TError = {
     message: string;
     code?: number | string;
+    file_id?: string;
+    tool_resource?: EToolResources;
     response?: {
         data?: {
             message?: string;
@@ -287,6 +353,17 @@ export type TForkConvoResponse = {
     conversation: TConversation;
     messages: TMessage[];
 };
+export type TForkSharedConvoRequest = {
+    shareId: string;
+    /** Index of the viewer's active message within the shared payload; reduces the
+     *  fork to that branch. An index is used because shared ids are re-anonymized
+     *  per request and `createdAt` can collide, while the payload order is stable. */
+    targetMessageIndex?: number;
+    /** `updatedAt` of the shared payload being forked. The shareId survives an
+     *  owner update, so the server rejects a fork whose payload has since moved
+     *  instead of resolving the index against different messages. */
+    shareRevision?: string;
+};
 export type TSearchResults = {
     conversations: TConversation[];
     messages: TMessage[];
@@ -320,6 +397,8 @@ export type TConfig = {
         defaultParamsEndpoint?: string;
         reasoningFormat?: ReasoningParameterFormat;
         reasoningKey?: ReasoningResponseKey;
+        includeReasoningContent?: boolean;
+        includeReasoningHistory?: boolean;
         paramDefinitions?: Partial<SettingDefinition>[];
     };
 };
@@ -555,9 +634,11 @@ export type TCustomConfigSpeechResponse = {
 };
 export type TUserTermsResponse = {
     termsAccepted: boolean;
+    termsAcceptedAt: Date | string | null;
 };
 export type TAcceptTermsResponse = {
-    success: boolean;
+    message: string;
+    termsAcceptedAt: Date | string;
 };
 export type TBannerResponse = TBanner | null;
 export type TUpdateFeedbackRequest = {
@@ -619,3 +700,37 @@ export type TUpdateSkillNodeRequest = {
     parentId?: string | null;
     order?: number;
 };
+export type TLangfuseConnectionStatus = {
+    configured: boolean;
+    enabled: boolean;
+    destinations: TLangfuseDestinationOption[];
+    destination?: string;
+    publicKey?: string;
+    secretKeyPreview?: string;
+    updatedAt?: string;
+};
+export type TLangfuseDestinationOption = {
+    key: string;
+    baseUrl: string;
+};
+export type TUpdateLangfuseConnectionRequest = {
+    enabled: boolean;
+    destination: string;
+    publicKey: string;
+    secretKey?: string;
+};
+export type TLangfuseConnectionTestRequest = {
+    destination: string;
+    publicKey: string;
+    secretKey?: string;
+};
+export type TLangfuseConnectionTestErrorCode = 'invalid_credentials' | 'access_denied' | 'rate_limited' | 'server_error' | 'timeout' | 'unreachable' | 'missing_secret' | 'stored_secret_unavailable' | 'unexpected_response';
+export type TLangfuseConnectionTestResponse = {
+    success: true;
+} | {
+    success: false;
+    errorCode: TLangfuseConnectionTestErrorCode;
+};
+export type TLangfuseSessionLinkResponse = {
+    url: string | null;
+};

package/dist/types/upload.d.ts

@@ -0,0 +1,2 @@
+import type { TFileUpload } from './types/files';
+export declare function uploadEventStream(url: string, formData: FormData, signal?: AbortSignal | null): Promise<TFileUpload>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "librechat-data-provider",
-  "version": "0.8.508",
+  "version": "0.8.521",
   "description": "data services for librechat apps",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -45,7 +45,7 @@
   "dependencies": {
     "axios": "^1.16.0",
     "dayjs": "^1.11.13",
-    "js-yaml": "^4.2.0",
+    "js-yaml": "^4.3.1",
     "zod": "^3.22.4"
   },
   "devDependencies": {
@@ -61,14 +61,14 @@
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^24.12.4",
     "@types/react": "^18.2.18",
-    "@types/winston": "^2.4.4",
     "jest": "^30.2.0",
     "jest-junit": "^17.0.0",
     "openapi-types": "^12.1.3",
     "rimraf": "^6.1.3",
     "rollup": "^4.34.9",
     "tsdown": "^0.22.2",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "winston": "^3.17.0"
   },
   "peerDependencies": {
     "@tanstack/react-query": "^4.28.0"