librechat-data-provider 0.8.501 → 0.8.503

package/dist/types/types/assistants.d.ts

@@ -24,7 +24,10 @@ export declare enum Tools {
     retrieval = "retrieval",
     function = "function",
     memory = "memory",
-    ui_resources = "ui_resources"
+    ui_resources = "ui_resources",
+    skill = "skill",
+    read_file = "read_file",
+    bash_tool = "bash_tool"
 }
 export declare enum EToolResources {
     code_interpreter = "code_interpreter",
@@ -214,6 +217,18 @@ export type ToolOptions = {
  * Used to customize tool behavior per agent.
  */
 export type AgentToolOptions = Record<string, ToolOptions>;
+/**
+ * Configuration for spawning subagents (isolated-context child agents) from an agent.
+ * When `enabled` is true, the agent gets a subagent-spawn tool that can delegate work
+ * to either itself (when `allowSelf` is true) and/or the listed `agent_ids`.
+ */
+export type AgentSubagentsConfig = {
+    enabled?: boolean;
+    /** When true (default), the agent may spawn itself in an isolated context. */
+    allowSelf?: boolean;
+    /** Specific agents that may be spawned as subagents. */
+    agent_ids?: string[];
+};
 export type Agent = {
     _id?: string;
     id: string;
@@ -248,6 +263,13 @@ export type Agent = {
     support_contact?: SupportContact;
     /** Per-tool configuration options (deferred loading, allowed callers, etc.) */
     tool_options?: AgentToolOptions;
+    /** Optional allowlist of skill ObjectIds. Only applies when `skills_enabled`. */
+    skills?: string[];
+    /** Master toggle for skill use on this agent. `true` = active (full catalog unless
+     *  `skills` narrows it). `false`/undefined = inactive (no skills available). */
+    skills_enabled?: boolean;
+    /** Subagent spawning configuration — isolated-context child agents. */
+    subagents?: AgentSubagentsConfig;
 };
 export type TAgentsMap = Record<string, Agent | undefined>;
 export type AgentCreateParams = {
@@ -260,7 +282,7 @@ export type AgentCreateParams = {
     provider: AgentProvider;
     model: string | null;
     model_parameters: AgentModelParameters;
-} & Pick<Agent, 'agent_ids' | 'edges' | 'end_after_tools' | 'hide_sequential_outputs' | 'artifacts' | 'recursion_limit' | 'category' | 'support_contact' | 'tool_options'>;
+} & Pick<Agent, 'agent_ids' | 'edges' | 'end_after_tools' | 'hide_sequential_outputs' | 'artifacts' | 'recursion_limit' | 'category' | 'support_contact' | 'tool_options' | 'skills' | 'skills_enabled' | 'subagents'>;
 export type AgentUpdateParams = {
     name?: string | null;
     description?: string | null;
@@ -272,7 +294,7 @@ export type AgentUpdateParams = {
     provider?: AgentProvider;
     model?: string | null;
     model_parameters?: AgentModelParameters;
-} & Pick<Agent, 'agent_ids' | 'edges' | 'end_after_tools' | 'hide_sequential_outputs' | 'artifacts' | 'recursion_limit' | 'category' | 'support_contact' | 'tool_options'>;
+} & Pick<Agent, 'agent_ids' | 'edges' | 'end_after_tools' | 'hide_sequential_outputs' | 'artifacts' | 'recursion_limit' | 'category' | 'support_contact' | 'tool_options' | 'skills' | 'skills_enabled' | 'subagents'>;
 export type AgentListParams = {
     limit?: number;
     requiredPermission: number;

package/dist/types/types/files.d.ts

@@ -1,4 +1,5 @@
 import { EToolResources } from './assistants';
+import type { CodeEnvRef } from '../codeEnvRef';
 export declare enum FileSources {
     local = "local",
     firebase = "firebase",
@@ -6,6 +7,7 @@ export declare enum FileSources {
     azure_blob = "azure_blob",
     openai = "openai",
     s3 = "s3",
+    cloudfront = "cloudfront",
     vectordb = "vectordb",
     execute_code = "execute_code",
     mistral_ocr = "mistral_ocr",
@@ -24,6 +26,7 @@ export declare enum FileContext {
     image_generation = "image_generation",
     assistants_output = "assistants_output",
     message_attachment = "message_attachment",
+    skill_file = "skill_file",
     filename = "filename",
     updatedAt = "updatedAt",
     source = "source",
@@ -42,6 +45,9 @@ export type FileConfig = {
     endpoints: {
         [key: string]: EndpointFileConfig;
     };
+    skills?: {
+        fileSizeLimit?: number;
+    };
     fileTokenLimit?: number;
     serverFileSizeLimit?: number;
     avatarSizeLimit?: number;
@@ -66,6 +72,9 @@ export type FileConfigInput = {
     endpoints?: {
         [key: string]: EndpointFileConfig;
     };
+    skills?: {
+        fileSizeLimit?: number;
+    };
     serverFileSizeLimit?: number;
     avatarSizeLimit?: number;
     clientImageResize?: {
@@ -89,6 +98,9 @@ export type TFile = {
     _id?: string;
     __v?: number;
     user: string;
+    tenantId?: string;
+    storageRegion?: string;
+    storageKey?: string;
     conversationId?: string;
     message?: string;
     file_id: string;
@@ -107,8 +119,38 @@ export type TFile = {
     height?: number;
     expiresAt?: string | Date;
     preview?: string;
+    text?: string;
+    /**
+     * Format of the `text` field. `'html'` means the backend produced
+     * a sanitized full-document HTML preview the client may inject as
+     * `index.html` inside the office artifact iframe. `'text'` (or
+     * `undefined` for legacy records) is plain text and MUST NOT be
+     * injected as HTML — render through the markdown/escaping path.
+     * See Codex P1 review on PR #12934.
+     */
+    textFormat?: 'html' | 'text' | null;
+    /**
+     * Lifecycle of the inline preview rendered from `text`. `'pending'`
+     * while background HTML extraction is in flight (deferred-preview
+     * code-execution flow), `'ready'` once `text`/`textFormat` are set,
+     * `'failed'` if extraction errored or hit the 60s ceiling. `undefined`
+     * for legacy records and for files that never expect a preview —
+     * clients MUST treat that as `'ready'`.
+     */
+    status?: 'pending' | 'ready' | 'failed';
+    /**
+     * Short machine-readable failure reason when `status === 'failed'`.
+     * Suitable for tooltip text but not user-facing prose.
+     */
+    previewError?: string;
     metadata?: {
         fileIdentifier?: string;
+        /**
+         * Structured form of `fileIdentifier`. Persisted alongside the
+         * legacy string during the dual-write transition; readers should
+         * resolve via `resolveCodeEnvRef`.
+         */
+        codeEnvRef?: CodeEnvRef;
     };
     createdAt?: string | Date;
     updatedAt?: string | Date;
@@ -116,9 +158,36 @@ export type TFile = {
 export type TFileUpload = TFile & {
     temp_file_id: string;
 };
+/**
+ * Shape returned by `GET /api/files/:file_id/preview`. The deferred-
+ * preview code-execution flow polls this until status is terminal:
+ *   - `pending`: HTML extraction is still running. No `text`.
+ *   - `ready`: extraction succeeded; `text` + `textFormat` populated
+ *     iff the file produced inline preview content (binary/oversized
+ *     files reach `ready` with no text — render download-only).
+ *   - `failed`: extraction errored or hit the 60s ceiling;
+ *     `previewError` carries the short reason (`timeout`,
+ *     `parser-error`, `orphaned`, etc.).
+ *
+ * Legacy records pre-dating the field are surfaced as `'ready'` server-
+ * side so existing attachments keep rendering normally.
+ */
+export type TFilePreview = {
+    file_id: string;
+    status: 'pending' | 'ready' | 'failed';
+    text?: string;
+    textFormat?: 'html' | 'text' | null;
+    previewError?: string;
+};
 export type AvatarUploadResponse = {
     url: string;
 };
+export type FileDownloadURLResponse = {
+    url: string;
+    filename: string;
+    type: string;
+    metadata: Partial<TFile>;
+};
 export type SpeechToTextResponse = {
     text: string;
 };
@@ -155,6 +224,8 @@ export type DeleteFilesResponse = {
 export type BatchFile = {
     file_id: string;
     filepath: string;
+    storageRegion?: string;
+    storageKey?: string;
     embedded: boolean;
     source: FileSources;
     temp_file_id?: string;

package/dist/types/types/mutations.d.ts

@@ -3,6 +3,8 @@ import * as r from '../roles';
 import * as p from '../permissions';
 import { Tools, Assistant, AssistantCreateParams, AssistantUpdateParams, FunctionTool, AssistantDocument, Agent, AgentCreateParams, AgentUpdateParams } from './assistants';
 import { Action, ActionMetadata } from './agents';
+import type { InfiniteData, QueryKey } from '@tanstack/react-query';
+import type { TSkill, TSkillFile, TCreateSkill, TUpdateSkillVariables, TUpdateSkillResponse, TDeleteSkillResponse, TUploadSkillFileVariables, TDeleteSkillFileVariables, TDeleteSkillFileResponse, TSkillListResponse } from './skills';
 export type MutationOptions<Response, Request, Context = unknown, Error = unknown, Snapshot = void> = {
     onSuccess?: (data: Response, variables: Request, context?: Context) => void;
     onMutate?: (variables: Request) => Snapshot | Promise<Snapshot>;
@@ -143,16 +145,59 @@ export type UpdateMemoryPermVars = UpdatePermVars<p.TMemoryPermissions>;
 export type UpdateAgentPermVars = UpdatePermVars<p.TAgentPermissions>;
 export type UpdatePeoplePickerPermVars = UpdatePermVars<p.TPeoplePickerPermissions>;
 export type UpdateMCPServersPermVars = UpdatePermVars<p.TMcpServersPermissions>;
+export type UpdateSkillPermVars = UpdatePermVars<p.TSkillPermissions>;
 export type UpdatePermResponse = r.TRole;
+/**
+ * Cache entries that can appear under the `[QueryKeys.skills, ...]` key prefix.
+ * Flat responses come from `useListSkillsQuery`; infinite responses come from
+ * `useSkillsInfiniteQuery`. The context carries both shapes for rollback.
+ */
+export type TSkillCacheEntry = TSkillListResponse | InfiniteData<TSkillListResponse> | undefined;
+export type TUpdateSkillContext = {
+    previousSkill?: TSkill;
+    previousListSnapshots?: Array<[QueryKey, TSkillCacheEntry]>;
+    userContext?: unknown;
+} | undefined;
+export type ImportSkillOptions = MutationOptions<TSkill, FormData>;
+export type CreateSkillOptions = MutationOptions<TSkill, TCreateSkill>;
+export type UpdateSkillOptions = MutationOptions<TUpdateSkillResponse, TUpdateSkillVariables, TUpdateSkillContext>;
+export type DeleteSkillOptions = MutationOptions<TDeleteSkillResponse, {
+    id: string;
+}>;
+export type UploadSkillFileOptions = MutationOptions<TSkillFile, TUploadSkillFileVariables>;
+export type DeleteSkillFileOptions = MutationOptions<TDeleteSkillFileResponse, TDeleteSkillFileVariables>;
 export type UpdatePromptPermOptions = MutationOptions<UpdatePermResponse, UpdatePromptPermVars, unknown, types.TError | null | undefined>;
 export type UpdateMemoryPermOptions = MutationOptions<UpdatePermResponse, UpdateMemoryPermVars, unknown, types.TError | null | undefined>;
 export type UpdateAgentPermOptions = MutationOptions<UpdatePermResponse, UpdateAgentPermVars, unknown, types.TError | null | undefined>;
 export type UpdatePeoplePickerPermOptions = MutationOptions<UpdatePermResponse, UpdatePeoplePickerPermVars, unknown, types.TError | null | undefined>;
 export type UpdateMCPServersPermOptions = MutationOptions<UpdatePermResponse, UpdateMCPServersPermVars, unknown, types.TError | null | undefined>;
+export type UpdateSkillPermOptions = MutationOptions<UpdatePermResponse, UpdateSkillPermVars, unknown, types.TError | null | undefined>;
 export type UpdateRemoteAgentsPermVars = UpdatePermVars<p.TRemoteAgentsPermissions>;
 export type UpdateRemoteAgentsPermOptions = MutationOptions<UpdatePermResponse, UpdateRemoteAgentsPermVars, unknown, types.TError | null | undefined>;
 export type UpdateMarketplacePermVars = UpdatePermVars<p.TMarketplacePermissions>;
 export type UpdateMarketplacePermOptions = MutationOptions<UpdatePermResponse, UpdateMarketplacePermVars, unknown, types.TError | null | undefined>;
+export type CreateSkillNodeBody = {
+    skillId: string;
+    data: FormData | types.TCreateSkillNodeRequest;
+};
+export type CreateSkillNodeOptions = MutationOptions<types.TSkillNode, CreateSkillNodeBody>;
+export type UpdateSkillNodeVariables = {
+    skillId: string;
+    nodeId: string;
+    data: types.TUpdateSkillNodeRequest;
+};
+export type UpdateSkillNodeOptions = MutationOptions<types.TSkillNode, UpdateSkillNodeVariables>;
+export type DeleteSkillNodeBody = {
+    skillId: string;
+    nodeId: string;
+};
+export type DeleteSkillNodeOptions = MutationOptions<void, DeleteSkillNodeBody>;
+export type UpdateSkillNodeContentVariables = {
+    skillId: string;
+    nodeId: string;
+    content: string;
+};
+export type UpdateSkillNodeContentOptions = MutationOptions<types.TSkillNode, UpdateSkillNodeContentVariables>;
 export type UpdateConversationTagOptions = MutationOptions<types.TConversationTag, types.TConversationTagRequest>;
 export type DeleteConversationTagOptions = MutationOptions<types.TConversationTag, string>;
 export type AcceptTermsMutationOptions = MutationOptions<types.TAcceptTermsResponse, void, unknown, void>;
@@ -169,6 +214,7 @@ export type ToolParams<T extends ToolId> = ToolParamsMap[T] & {
     partIndex?: number;
     blockIndex?: number;
     conversationId: string;
+    isTemporary?: boolean;
 };
 export type ToolCallResponse = {
     result: unknown;

package/dist/types/types/queries.d.ts

@@ -178,6 +178,8 @@ export type TUserFavorite = {
     model?: string;
     endpoint?: string;
     spec?: string;
+    /** Phase 2 — skill favoriting isn't persisted yet, but the shape is reserved. */
+    skillId?: string;
 };
 export type GraphTokenParams = {
     scopes: string;

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

@@ -32,5 +32,24 @@ export declare enum StepEvents {
     ON_RUN_STEP_COMPLETED = "on_run_step_completed",
     ON_SUMMARIZE_START = "on_summarize_start",
     ON_SUMMARIZE_DELTA = "on_summarize_delta",
-    ON_SUMMARIZE_COMPLETE = "on_summarize_complete"
+    ON_SUMMARIZE_COMPLETE = "on_summarize_complete",
+    ON_SUBAGENT_UPDATE = "on_subagent_update"
+}
+/** Lifecycle phase carried on subagent-progress envelopes (mirrors SDK SubagentUpdatePhase). */
+export type SubagentUpdatePhase = 'start' | 'run_step' | 'run_step_delta' | 'run_step_completed' | 'message_delta' | 'reasoning_delta' | 'stop' | 'error';
+/** Single streamed subagent update forwarded by the SDK's SubagentExecutor. */
+export interface SubagentUpdateEvent {
+    runId: string;
+    subagentRunId: string;
+    /** Parent-side `tool_call_id` for the `subagent` tool invocation that
+     *  triggered this run. Surfaces from the SDK (`3.1.67-dev.2`+) so hosts
+     *  can correlate child progress to the parent tool call deterministically. */
+    parentToolCallId?: string;
+    subagentType: string;
+    subagentAgentId: string;
+    parentAgentId?: string;
+    phase: SubagentUpdatePhase;
+    data?: unknown;
+    label?: string;
+    timestamp: string;
 }

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

@@ -0,0 +1,275 @@
+import type { FileSources } from './files';
+/**
+ * Shared skill validation constants — the single source of truth for name,
+ * description, title, body, and file-path length limits. Mirrored by
+ * `packages/data-schemas/src/methods/skill.ts`; whenever those constants
+ * change, the DB-side validators MUST be updated to match.
+ *
+ * Exported from `librechat-data-provider` so both frontend form validators
+ * and backend Mongoose pre-save hooks use the same literals.
+ */
+export declare const SKILL_NAME_MAX_LENGTH = 64;
+export declare const SKILL_DESCRIPTION_MAX_LENGTH = 1024;
+export declare const SKILL_DESCRIPTION_SHORT_THRESHOLD = 20;
+export declare const SKILL_DISPLAY_TITLE_MAX_LENGTH = 128;
+export declare const SKILL_BODY_MAX_LENGTH = 100000;
+/**
+ * Kebab-case identifier pattern: must start with a lowercase letter or digit,
+ * and contain only lowercase letters, digits, and hyphens. Mirrors the
+ * backend `SKILL_NAME_PATTERN` in `packages/data-schemas/src/methods/skill.ts`.
+ */
+export declare const SKILL_NAME_PATTERN: RegExp;
+/**
+ * Source of a skill — where its canonical definition came from.
+ * `inline` means the skill was authored directly in LibreChat.
+ * `github` / `notion` are reserved for future sync integrations.
+ */
+export type SkillSource = 'inline' | 'github' | 'notion';
+/**
+ * Category inferred from a skill file's top-level directory prefix.
+ * `script` for `scripts/...`, `reference` for `references/...`, `asset` for `assets/...`,
+ * everything else (including root-level files) is `other`.
+ */
+export type SkillFileCategory = 'script' | 'reference' | 'asset' | 'other';
+/**
+ * Allowed value types inside a skill's YAML frontmatter.
+ * Kept strict so callers cannot slip arbitrary `unknown` payloads through the API.
+ */
+export type SkillFrontmatterValue = string | number | boolean | string[] | null;
+/**
+ * Structured YAML frontmatter for a skill. All keys are optional on the wire
+ * because not every skill document carries a complete frontmatter block —
+ * `name` and `description` live as first-class columns on `TSkill` itself,
+ * and frontmatter is an extension bag for additional fields like `when-to-use`,
+ * `allowed-tools`, etc.
+ */
+export type SkillFrontmatter = {
+    name?: string;
+    description?: string;
+} & Record<string, SkillFrontmatterValue | undefined>;
+/**
+ * Provenance metadata for skills that originated from an external source
+ * (e.g. a GitHub commit SHA or a Notion page id).
+ *
+ * Reserved for phase 2+ external sync — no code path currently populates this
+ * in phase 1, but the column exists so a future sync worker can use it
+ * without a schema migration.
+ */
+export type SkillSourceMetadata = Record<string, string | number | boolean>;
+/**
+ * A non-blocking coaching hint surfaced alongside a successful create/update
+ * response. Unlike validation errors (which return 400 and block the write),
+ * warnings ride on the 2xx response so the UI can show inline feedback
+ * without rejecting the user's input. Example: "description is too short,
+ * Claude may undertrigger this skill".
+ */
+export type TSkillWarning = {
+    field: string;
+    code: string;
+    message: string;
+    severity: 'warning';
+};
+/**
+ * API shape for a full skill (returned by GET `/api/skills/:id`).
+ *
+ * Field semantics:
+ * - `name` is the machine-readable kebab-case identifier Claude sees in its
+ *   skill manifest. It's what drives triggering and must be stable across
+ *   edits. Unique per author+tenant.
+ * - `displayTitle` is the human-readable UI label only. NOT sent to Claude,
+ *   NOT part of the trigger path — purely cosmetic.
+ * - `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.
+ * - `source`/`sourceMetadata` are reserved for phase 2+ external sync and
+ *   always `'inline'` / absent in phase 1.
+ */
+export type TSkill = {
+    _id: string;
+    name: string;
+    displayTitle?: string;
+    description: string;
+    body: string;
+    frontmatter?: SkillFrontmatter;
+    category?: string;
+    /**
+     * @deprecated Replaced by the persisted `userInvocable` /
+     * `disableModelInvocation` pair derived from frontmatter. Retained
+     * temporarily so older form code that hasn't migrated still type-checks;
+     * the backend no longer reads or writes it.
+     */
+    invocationMode?: import('../types').InvocationMode;
+    /**
+     * Mirrors the `disable-model-invocation` frontmatter field. `true` means
+     * the model can no longer invoke this skill via the `skill` tool and the
+     * skill is excluded from the catalog injected into the system prompt.
+     * Manual `$` invocation is unaffected.
+     */
+    disableModelInvocation?: boolean;
+    /**
+     * Mirrors the `user-invocable` frontmatter field. `false` hides the skill
+     * from the `$` popover and rejects manual invocation. Defaults to `true`.
+     */
+    userInvocable?: boolean;
+    /**
+     * Skill-declared tool allowlist (mirrors the `allowed-tools` frontmatter
+     * field). When the skill is invoked, these tools are unioned into the
+     * agent's effective tool set for the turn. Tolerant of unknown names —
+     * the runtime intersects against the loaded tool registry, so skills
+     * referencing yet-to-be-implemented tools import without breaking.
+     */
+    allowedTools?: string[];
+    author: string;
+    authorName: string;
+    version: number;
+    source: SkillSource;
+    sourceMetadata?: SkillSourceMetadata;
+    fileCount: number;
+    /**
+     * When `true`, the skill auto-primes into every turn — no user `$` picks
+     * or model discretion required. Surfaced on the list view so the UI can
+     * show a pin badge on rows that apply ambiently.
+     */
+    alwaysApply?: boolean;
+    isPublic?: boolean;
+    tenantId?: string;
+    createdAt: string;
+    updatedAt: string;
+    /**
+     * Present on POST/PATCH responses when the server emitted non-blocking
+     * coaching warnings (e.g. description too short). Never present on GET
+     * responses.
+     */
+    warnings?: TSkillWarning[];
+};
+/**
+ * Summary shape used in list endpoints — omits `body` and `frontmatter` to keep
+ * list payloads small. Callers that need the full body/frontmatter must fetch
+ * the detail via `GET /api/skills/:id`.
+ */
+export type TSkillSummary = Omit<TSkill, 'body' | 'frontmatter'>;
+/**
+ * Metadata for a single file bundled inside a skill.
+ * File content itself is fetched separately via the file download endpoint.
+ */
+export type TSkillFile = {
+    _id: string;
+    skillId: string;
+    relativePath: string;
+    file_id: string;
+    filename: string;
+    filepath: string;
+    storageKey?: string;
+    storageRegion?: string;
+    source: FileSources;
+    mimeType: string;
+    bytes: number;
+    category: SkillFileCategory;
+    isExecutable: boolean;
+    author: string;
+    tenantId?: string;
+    /** Lazily cached text content (≤ 512 KB). Excluded from list responses. */
+    content?: string;
+    /** Set on first read. `true` prevents repeated storage reads for non-text files. */
+    isBinary?: boolean;
+    createdAt: string;
+    updatedAt: string;
+};
+/** Request body for POST `/api/skills`. */
+export type TCreateSkill = {
+    name: string;
+    displayTitle?: string;
+    description: string;
+    body: string;
+    frontmatter?: Partial<SkillFrontmatter>;
+    category?: string;
+    /** When `true`, the skill auto-primes into every turn (mirrors `always-apply` frontmatter). */
+    alwaysApply?: boolean;
+};
+/** Partial payload for PATCH `/api/skills/:id` — all fields optional. */
+export type TUpdateSkillPayload = {
+    name?: string;
+    displayTitle?: string;
+    description?: string;
+    body?: string;
+    frontmatter?: Partial<SkillFrontmatter>;
+    category?: string;
+    alwaysApply?: boolean;
+};
+/** Variables passed into the update mutation: id + expectedVersion + partial payload. */
+export type TUpdateSkillVariables = {
+    id: string;
+    expectedVersion: number;
+    payload: TUpdateSkillPayload;
+};
+/** Response from a successful PATCH — includes the bumped version. */
+export type TUpdateSkillResponse = TSkill;
+/** Response from a 409 concurrency conflict — includes the current authoritative state. */
+export type TSkillConflictResponse = {
+    error: 'skill_version_conflict';
+    current: TSkill;
+};
+/** Query params for GET `/api/skills` (list). */
+export type TSkillListRequest = {
+    category?: string;
+    search?: string;
+    limit?: number;
+    cursor?: string;
+};
+/** Paginated list response. `after` is the cursor to pass for the next page. */
+export type TSkillListResponse = {
+    skills: TSkillSummary[];
+    has_more: boolean;
+    after: string | null;
+};
+/** Response from DELETE `/api/skills/:id`. */
+export type TDeleteSkillResponse = {
+    id: string;
+    deleted: true;
+};
+/** Response from GET `/api/skills/:id/files`. */
+export type TListSkillFilesResponse = {
+    files: TSkillFile[];
+};
+/**
+ * Upload body for POST `/api/skills/:id/files`.
+ * In phase 1 the backend responds with 501; the client contract is still defined here
+ * so hooks are stable when the upload pipeline is wired up in phase 2.
+ */
+export type TUploadSkillFilePayload = {
+    relativePath: string;
+};
+/** Response from DELETE `/api/skills/:id/files/:relativePath`. */
+export type TDeleteSkillFileResponse = {
+    skillId: string;
+    relativePath: string;
+    deleted: true;
+};
+/** Response from GET `/api/skills/:id/files/:relativePath` (JSON mode). */
+export type TSkillFileContentResponse = {
+    content?: string;
+    mimeType: string;
+    isBinary: boolean;
+    relativePath: string;
+    filename: string;
+    bytes: number;
+};
+/** Variables passed into the skill file upload mutation. */
+export type TUploadSkillFileVariables = {
+    skillId: string;
+    formData: FormData;
+};
+/** Variables passed into the skill file delete mutation. */
+export type TDeleteSkillFileVariables = {
+    skillId: string;
+    relativePath: string;
+};
+/**
+ * Per-user skill active/inactive overrides (GET response and POST body payload).
+ * Key = skill ObjectId string, value = explicit active state.
+ * Skills absent from the map use the ownership-based default:
+ * owned = active, shared = `defaultActiveOnShare` from config.
+ */
+export type TSkillStatesResponse = Record<string, boolean>;

package/dist/types/types/web.d.ts

@@ -1,4 +1,6 @@
 import type { Logger as WinstonLogger } from 'winston';
+import type { z } from 'zod';
+import type { webSearchSchema } from '../config';
 export type SearchRefType = 'search' | 'image' | 'news' | 'video' | 'ref';
 export declare enum DATE_RANGE {
     PAST_HOUR = "h",
@@ -7,7 +9,8 @@ export declare enum DATE_RANGE {
     PAST_MONTH = "m",
     PAST_YEAR = "y"
 }
-export type SearchProvider = 'serper' | 'searxng';
+export type SearchProvider = 'serper' | 'searxng' | 'tavily';
+export type ScraperProvider = 'firecrawl' | 'serper' | 'tavily';
 export type RerankerType = 'infinity' | 'jina' | 'cohere' | 'none';
 export interface Highlight {
     score: number;
@@ -65,6 +68,9 @@ export interface SearchConfig {
     serperApiKey?: string;
     searxngInstanceUrl?: string;
     searxngApiKey?: string;
+    tavilyApiKey?: string;
+    tavilySearchUrl?: string;
+    tavilySearchOptions?: TavilyConfig['tavilySearchOptions'];
 }
 export type References = {
     links: MediaReference[];
@@ -117,6 +123,13 @@ export interface FirecrawlConfig {
         };
     };
 }
+export interface TavilyConfig {
+    tavilyApiKey?: string;
+    tavilySearchUrl?: string;
+    tavilyExtractUrl?: string;
+    tavilySearchOptions?: z.infer<typeof webSearchSchema>['tavilySearchOptions'];
+    tavilyScraperOptions?: z.infer<typeof webSearchSchema>['tavilyScraperOptions'];
+}
 export interface ScraperContentResult {
     content: string;
 }