librechat-data-provider 0.8.523 → 0.8.524

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

@@ -4,6 +4,15 @@
  * 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 = {
@@ -22,6 +31,11 @@ export type TTraceRecord = {
     /** `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. */
@@ -34,6 +48,8 @@ export type TTraceRecord = {
     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 = {
@@ -72,10 +88,43 @@ 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;

package/dist/types/types.d.ts

@@ -2,13 +2,15 @@ import type { InfiniteData } from '@tanstack/react-query';
 import type { TConversationTag, EModelEndpoint, TConversation, TSharedLink, TAttachment, TMessage, TBanner, ReasoningResponseKey, ReasoningParameterFormat } from './schemas';
 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 { 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[];
@@ -347,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'>;
@@ -454,7 +459,32 @@ export type TCodeEnvironmentStatusResponse = {
     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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "librechat-data-provider",
-  "version": "0.8.523",
+  "version": "0.8.524",
   "description": "data services for librechat apps",
   "main": "dist/index.js",
   "module": "dist/index.mjs",