librechat-data-provider 0.8.521 → 0.8.523

package/dist/types/types/subagents.d.ts

@@ -0,0 +1,159 @@
+export type SubagentThreadStatus = 'dispatched' | 'running' | 'completed' | 'failed' | 'interrupted' | 'cancelled';
+export type ParentSubagentTaskSummary = {
+    taskId: string;
+    status: SubagentThreadStatus;
+    createdAt?: string;
+};
+/**
+ * Bounded discovery projection for one child owned by a parent conversation.
+ * Event-delivery identities stay private; `actorId` is the only event-binding
+ * field intentionally exposed to the parent's UI.
+ */
+export type ParentSubagentSummary = {
+    threadId: string;
+    parentMessageId: string;
+    /** Present only for ordinary tool-spawned children. */
+    parentToolCallId?: string;
+    subagentType: string;
+    subagentKind: 'agent' | 'graph';
+    agentId?: string;
+    title: string;
+    origin: 'tool' | 'event';
+    actorId?: string;
+    status: SubagentThreadStatus;
+    updatedAt?: string;
+    latestTaskId?: string;
+    tasks: ParentSubagentTaskSummary[];
+    tasksTruncated: boolean;
+};
+export type ParentSubagentIndex = {
+    parentConversationId: string;
+    children: ParentSubagentSummary[];
+    childrenTruncated: boolean;
+};
+/**
+ * A bounded, presentation-safe description of child work. This deliberately
+ * models user-visible activity instead of the LangChain messages, SSE events,
+ * or durable records that produced it.
+ */
+export type SubagentActivityItem = {
+    type: 'writing';
+    text: string;
+    textTruncated?: boolean;
+} | {
+    type: 'reasoning';
+    /** Bounded user-visible reasoning text; absent on projections persisted
+     *  before reasoning retention (rendered as a marker). */
+    text?: string;
+    textTruncated?: boolean;
+} | {
+    type: 'activity_label';
+    label: string;
+    labelType?: 'phase';
+    toolCallIds?: string[];
+    activityStartIndex?: number;
+    activityEndIndex?: number;
+    activityCount?: number;
+    agentIds?: string[];
+    status?: 'ok' | 'partial' | 'failed';
+    pending?: boolean;
+    labelTruncated?: boolean;
+} | {
+    type: 'tool';
+    toolCallId: string;
+    name: string;
+    input?: string;
+    output?: string;
+    status: 'running' | 'completed' | 'failed' | 'cancelled';
+    inputValidationError?: true;
+    inputTruncated?: boolean;
+    outputTruncated?: boolean;
+};
+export type SubagentControlAction = 'steer' | 'queue' | 'interrupt' | 'cancel' | 'cancel_message';
+export type SubagentControlReceipt = {
+    invocationId: string;
+    controlId?: string;
+    action: SubagentControlAction;
+    status: 'accepted' | 'applied' | 'rejected' | 'failed';
+    createdAt: string;
+    updatedAt: string;
+    boundary?: 'preempt' | 'tool' | 'turn';
+    reason?: string;
+    message?: string;
+    messageTruncated?: boolean;
+};
+export type SubagentControlRequest = {
+    taskId: string;
+    invocationId: string;
+    action: SubagentControlAction;
+    message?: string;
+    controlId?: string;
+};
+export type SubagentControlResponse = {
+    receipt: SubagentControlReceipt;
+};
+export type SubagentThreadMessage = {
+    messageId: string;
+    parentMessageId: string | null;
+    role: 'user' | 'assistant';
+    text: string;
+    createdAt?: string;
+    error?: boolean;
+    textTruncated?: boolean;
+};
+export type SubagentThreadTriggerKind = 'parent_dispatch' | 'parent_continuation' | 'external_event';
+export type SubagentExternalEventDetails = {
+    eventType: string;
+    sourceType: string;
+    occurredAt: string;
+    expectedActionToolName?: string;
+};
+/**
+ * One chronological child execution boundary. The trigger is host-authored,
+ * while activity and messages are bounded public projections of the child run.
+ */
+export type SubagentThreadTurn = {
+    taskId: string;
+    trigger: {
+        kind: SubagentThreadTriggerKind;
+        summary: string;
+        createdAt?: string;
+        summaryTruncated?: boolean;
+        externalEvent?: SubagentExternalEventDetails;
+    };
+    status: SubagentThreadStatus;
+    activity: SubagentActivityItem[];
+    activityTruncated: boolean;
+    controlReceipts?: SubagentControlReceipt[];
+    controlReceiptsTruncated?: boolean;
+    messages: SubagentThreadMessage[];
+};
+export type SubagentThreadView = {
+    threadId: string;
+    parentConversationId: string;
+    parentMessageId: string;
+    parentToolCallId: string;
+    subagentType: string;
+    subagentKind: 'agent' | 'graph';
+    /** Product recursion level, currently bounded to one by the host runtime. */
+    depth?: number;
+    agentId?: string;
+    title: string;
+    status: SubagentThreadStatus;
+    /** Activity for the exact task requested by the parent card, when retained. */
+    activity: SubagentActivityItem[];
+    activityTruncated: boolean;
+    /** Bounded authoritative parent-to-child command receipts for this task. */
+    controlReceipts?: SubagentControlReceipt[];
+    /** True when older authoritative command receipts were omitted from this view. */
+    controlReceiptsTruncated?: boolean;
+    /** Chronological, branch-selected child history for conversation-native rendering. */
+    turns?: SubagentThreadTurn[];
+    messages: SubagentThreadMessage[];
+    historyTruncated: boolean;
+    /** True when some branch rows were omitted and cannot be recovered with `nextCursor`. */
+    historyUnavailable?: boolean;
+    /** Opaque task-message cursor for the next older bounded branch page. */
+    nextCursor?: string;
+    updatedAt?: string;
+};

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/web.d.ts

@@ -9,8 +9,8 @@ export declare enum DATE_RANGE {
     PAST_MONTH = "m",
     PAST_YEAR = "y"
 }
-export type SearchProvider = 'serper' | 'searxng' | 'tavily';
-export type ScraperProvider = 'firecrawl' | 'serper' | 'tavily';
+export type SearchProvider = 'serper' | 'searxng' | 'tavily' | 'keenable';
+export type ScraperProvider = 'firecrawl' | 'serper' | 'tavily' | 'keenable';
 export type RerankerType = 'infinity' | 'jina' | 'cohere' | 'none';
 export interface Highlight {
     score: number;
@@ -68,9 +68,13 @@ export interface SearchConfig {
     serperApiKey?: string;
     searxngInstanceUrl?: string;
     searxngApiKey?: string;
+    searxngSearchOptions?: z.infer<typeof webSearchSchema>['searxngSearchOptions'];
     tavilyApiKey?: string;
     tavilySearchUrl?: string;
     tavilySearchOptions?: TavilyConfig['tavilySearchOptions'];
+    keenableApiKey?: string;
+    keenableApiUrl?: string;
+    keenableSearchOptions?: KeenableConfig['keenableSearchOptions'];
 }
 export type References = {
     links: MediaReference[];
@@ -130,6 +134,12 @@ export interface TavilyConfig {
     tavilySearchOptions?: z.infer<typeof webSearchSchema>['tavilySearchOptions'];
     tavilyScraperOptions?: z.infer<typeof webSearchSchema>['tavilyScraperOptions'];
 }
+export interface KeenableConfig {
+    keenableApiKey?: string;
+    keenableApiUrl?: string;
+    keenableSearchOptions?: z.infer<typeof webSearchSchema>['keenableSearchOptions'];
+    keenableScraperOptions?: z.infer<typeof webSearchSchema>['keenableScraperOptions'];
+}
 export interface ScraperContentResult {
     content: string;
 }

package/dist/types/types.d.ts

@@ -1,11 +1,16 @@
 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 { 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';
 import type { ContentTypes } from './types/runs';
+import type { ProviderId } from './providers';
 export * from './schemas';
+export * from './types/subagents';
 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'> & {
     modelDisplayLabel?: string;
@@ -48,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;
@@ -62,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;
     /**
@@ -98,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;
@@ -134,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. */
@@ -200,10 +223,18 @@ export type TUser = {
     backupCodes?: TBackupCode[];
     personalization?: {
         memories?: boolean;
+        statefulCodeEnvironment?: StatefulCodeEnvironment;
     };
     createdAt: string;
     updatedAt: string;
 };
+export type TUpdateUserPreferencesRequest = {
+    statefulCodeEnvironment: StatefulCodeEnvironment;
+};
+export type TUpdateUserPreferencesResponse = {
+    updated: boolean;
+    preferences: TUpdateUserPreferencesRequest;
+};
 export type TGetConversationsResponse = {
     conversations: TConversation[];
     pageNumber: string;
@@ -305,6 +336,9 @@ export type TArchiveConversationRequest = {
     isArchived: boolean;
 };
 export type TArchiveConversationResponse = TConversation;
+export type TArchiveAllConversationsResponse = {
+    archivedCount: number;
+};
 export type TPinConversationRequest = {
     conversationId: string;
     pinned: boolean;
@@ -312,6 +346,7 @@ export type TPinConversationRequest = {
 export type TPinConversationResponse = TConversation;
 export type TSharedMessagesResponse = Omit<TSharedLink, 'messages'> & {
     messages: TMessage[];
+    langfuseSessionUrl?: string;
 };
 export type TCreateShareLinkRequest = Pick<TConversation, 'conversationId'>;
 export type TUpdateShareLinkRequest = Pick<TSharedLink, 'shareId' | 'targetMessageId'>;
@@ -372,6 +407,53 @@ export type TSearchResults = {
     pages: string | number;
     filter: object;
 };
+export type TPublicCodeEnvironment = {
+    id: string;
+    name: string;
+    type: 'managed' | 'attached';
+    default?: boolean;
+    pairingAvailable?: boolean;
+    configSchema?: CodeEnvironmentUserConfigSchema;
+    settings?: CodeEnvironmentUserSettings;
+};
+export type TCodeEnvironmentSummary = {
+    resourceId: string;
+    id: string;
+    name: string;
+    type: 'managed' | 'attached';
+    canEdit?: boolean;
+    canDelete: boolean;
+    configSchema?: CodeEnvironmentUserConfigSchema;
+    settings?: CodeEnvironmentUserSettings;
+};
+export type TCodeControlPlane = {
+    id: string;
+    name: string;
+    configSchema?: CodeEnvironmentUserConfigSchema;
+};
+export type TCodeEnvironmentsResponse = {
+    environments: TCodeEnvironmentSummary[];
+    controlPlanes: TCodeControlPlane[];
+};
+export type TCodeEnvironmentPairingResponse = {
+    environment: TCodeEnvironmentSummary;
+    pairing: {
+        workerId: string;
+        code: string;
+        expiresAt: string;
+        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;
@@ -382,6 +464,8 @@ export type TConfig = {
     plugins?: Record<string, string>;
     name?: string;
     iconURL?: string;
+    /** Canonical provider identity resolved at config load, used for branding. */
+    providerId?: ProviderId;
     version?: string;
     modelDisplayLabel?: string;
     userProvide?: boolean | null;
@@ -393,6 +477,20 @@ export type TConfig = {
     disableBuilder?: boolean;
     retrievalModels?: string[];
     capabilities?: string[];
+    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;
@@ -733,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.521",
+  "version": "0.8.523",
   "description": "data services for librechat apps",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -43,9 +43,11 @@
   },
   "homepage": "https://librechat.ai",
   "dependencies": {
-    "axios": "^1.16.0",
+    "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"
   },
   "devDependencies": {