librechat-data-provider 0.8.509 → 0.8.521

package/dist/types/types/agents.d.ts

@@ -1,5 +1,5 @@
+import type { TTokenUsageEvent, TContextUsageEvent, TPendingSteer } from './runs';
 import type { FunctionToolCall, SummaryContentPart } from './assistants';
-import type { TTokenUsageEvent, TContextUsageEvent } from './runs';
 import type { TAttachment, TPlugin } from 'src/schemas';
 import { StepTypes, ContentTypes, ToolCallTypes } from './runs';
 export declare namespace Agents {
@@ -62,10 +62,22 @@ export declare namespace Agents {
         id?: string;
         /** If provided, the output of the tool call */
         output?: string;
+        /** The tool call was rejected before execution because its input failed schema validation. */
+        inputValidationError?: true;
         /** Auth URL */
         auth?: string;
         /** Expiration time */
         expires_at?: number;
+        /**
+         * When set, this tool call is paused for human review.
+         * The presence of this field signals the UI to render approval controls
+         * instead of the in-flight tool execution state.
+         */
+        approval?: {
+            actionId: string;
+            allowed_decisions: ToolApprovalDecisionType[];
+            description?: string;
+        };
     };
     type ToolEndEvent = {
         /** The Step Id of the Tool Call */
@@ -179,6 +191,11 @@ export declare namespace Agents {
         parentMessageId?: string;
         conversationId?: string;
         text?: string;
+        /** Skill selections on the turn, carried so a HITL-resumed turn's reconstructed
+         *  requestMessage keeps its skill pills (they aren't on the DB row the client refetches
+         *  until reload). */
+        manualSkills?: string[];
+        alwaysAppliedSkills?: string[];
     }
     /** State data sent to reconnecting clients */
     interface ResumeState {
@@ -207,6 +224,18 @@ export declare namespace Agents {
         collectedUsage?: TTokenUsageEvent[];
         /** Latest context window snapshot; restores the usage gauge on resume */
         contextUsage?: TContextUsageEvent;
+        /**
+         * Live pending approval when the run is paused for human review. Carried in
+         * the resume contract (not just /chat/status) so a reloading or
+         * cross-replica client can rebuild and render the prompt from `resumeState`.
+         */
+        pendingAction?: PendingAction;
+        /**
+         * Steers queued server-side but not yet injected into the run. Injected
+         * steers already live inside `aggregatedContent`; these are the remainder,
+         * so a reconnecting client can rebuild its pending-steer chips.
+         */
+        pendingSteers?: TPendingSteer[];
     }
     /**
      * Represents a run step delta i.e. any changed fields on a run step during
@@ -227,6 +256,9 @@ export declare namespace Agents {
         type: StepTypes.MESSAGE_CREATION;
         message_creation: {
             message_id: string;
+            /** Provider content kind and Open Responses semantic text channel. */
+            content_type?: 'text' | 'think';
+            phase?: 'commentary' | 'final_answer';
         };
     };
     type ToolCallsDetails = {
@@ -238,8 +270,186 @@ export declare namespace Agents {
         tool_calls?: ToolCallChunk[];
         auth?: string;
         expires_at?: number;
+        /** Approval metadata, set when a tool call is paused for human review. */
+        approval?: {
+            actionId: string;
+            allowed_decisions: ToolApprovalDecisionType[];
+            description?: string;
+        };
     };
     type AgentToolCall = FunctionToolCall | ToolCall;
+    /**
+     * Human-in-the-loop interrupt categories. The discriminator on
+     * {@link HumanInterruptPayload}.
+     *
+     * - `tool_approval`: agent paused before executing one or more tools; user
+     *   approves / rejects / edits each call.
+     * - `ask_user_question`: agent invoked the `AskUserQuestion` tool to gather
+     *   clarification; user replies with free-form text (or selects an option).
+     *
+     * `tool_approval` is a permission gate; `ask_user_question` is a clarification
+     * channel — they share the {@link PendingAction} envelope but have different
+     * UI affordances and resume payloads.
+     */
+    type HumanInterruptType = 'tool_approval' | 'ask_user_question';
+    /** String enum of decision kinds the user can make on a paused tool call. */
+    type ToolApprovalDecisionType = 'approve' | 'reject' | 'edit' | 'respond';
+    /**
+     * One pending tool execution awaiting user review.
+     * Field naming mirrors LangChain HumanInterrupt's `ActionRequest`.
+     */
+    interface ToolApprovalRequest {
+        /** Tool name as registered with the agent */
+        name: string;
+        /** Sanitized arguments (no auth tokens / file blobs). May be string or parsed object. */
+        arguments: string | Record<string, unknown>;
+        /** Provider tool_call_id linking this request to the model's tool_use block */
+        tool_call_id: string;
+        /** Optional human-readable description shown alongside the prompt */
+        description?: string;
+    }
+    /**
+     * Per-call review configuration: which decisions the user is allowed to make.
+     *
+     * `tool_call_id` (NOT `action_name`) is the join key against
+     * {@link ToolApprovalRequest.tool_call_id}. By-position mapping breaks the
+     * moment a single batch contains the same tool called twice — e.g. a model
+     * fanning out two `mcp:server:search` calls in parallel — so always join
+     * by `tool_call_id`. `action_name` is retained for display only.
+     */
+    interface ToolReviewConfig {
+        action_name: string;
+        tool_call_id: string;
+        allowed_decisions: ToolApprovalDecisionType[];
+    }
+    /** Interrupt payload for a tool-approval pause. */
+    interface ToolApprovalInterruptPayload {
+        type: 'tool_approval';
+        action_requests: ToolApprovalRequest[];
+        review_configs: ToolReviewConfig[];
+    }
+    /** A selectable answer for an ask-user-question prompt. */
+    interface AskUserQuestionOption {
+        label: string;
+        value: string;
+    }
+    /** The question itself: free-form prompt with optional curated answers. */
+    interface AskUserQuestionRequest {
+        question: string;
+        /** Optional descriptive context for the prompt; mirrors the SDK field. */
+        description?: string;
+        options?: AskUserQuestionOption[];
+        /** When true the user may pick several options; the answer is their
+         *  selected option values joined with ", ". */
+        multiSelect?: boolean;
+    }
+    /** One independently answerable question in a batched clarification. */
+    interface AskUserQuestionBatchItem extends AskUserQuestionRequest {
+        /** Batch-unique identifier used to map the submitted answer. */
+        id: string;
+        /** Optional short heading rendered above the question. */
+        header?: string;
+    }
+    /** Input shape for one tool call that asks several related questions. */
+    interface AskUserQuestionsRequest {
+        questions: AskUserQuestionBatchItem[];
+    }
+    /** Interrupt payload for an ask-user-question pause. */
+    interface AskUserQuestionInterruptPayload {
+        type: 'ask_user_question';
+        question: AskUserQuestionRequest;
+        /** Present for a batched clarification; `question` remains the first-item fallback. */
+        questions?: AskUserQuestionBatchItem[];
+        /**
+         * The ask tool call that raised this interrupt (mirrors the SDK field,
+         * present from `@librechat/agents` > 3.3.8). Lets the question/answer
+         * stamps target the exact tool-call part instead of guessing by
+         * position when a model emits several ask calls in one turn.
+         */
+        tool_call_id?: string;
+    }
+    /**
+     * Discriminated by `type`. Mirrors `@librechat/agents`'s `HumanInterruptPayload`
+     * so the SDK's `Run.getInterrupt()` output can be embedded directly.
+     */
+    type HumanInterruptPayload = ToolApprovalInterruptPayload | AskUserQuestionInterruptPayload;
+    /**
+     * Server-side record of a job that is waiting for user input.
+     * Persisted with the job; consumed by approval routes and the status endpoint.
+     */
+    interface PendingAction {
+        /** Stable identifier used in approval URLs */
+        actionId: string;
+        streamId: string;
+        conversationId?: string;
+        /** Stable per-turn identifier (LangGraph checkpoint_ns) when available */
+        runId?: string;
+        responseMessageId?: string;
+        payload: HumanInterruptPayload;
+        createdAt: number;
+        /** Optional expiry; clients should treat past `expiresAt` as stale */
+        expiresAt?: number;
+        /**
+         * SDK interrupt id (`RunInterruptResult.interruptId`). Persisted so a
+         * cross-process resume can correlate the decision with the LangGraph
+         * interrupt after the original `Run` object is gone.
+         */
+        interruptId?: string;
+        /**
+         * LangGraph `thread_id` the run was bound to (`RunInterruptResult.threadId`).
+         * Required, with the checkpointer, to rebuild `Command({ resume })` on a
+         * worker that didn't originate the run.
+         */
+        threadId?: string;
+        /**
+         * Fingerprint of the request fields that determine the agent/graph + tool set
+         * (endpoint, agent_id, model, spec, ephemeralAgent), captured at pause time. The
+         * resume route recomputes it from the resume request and rejects a mismatch — the
+         * guard that catches an ephemeral-agent config swap, where `agent_id` is undefined
+         * so the id check can't.
+         */
+        requestFingerprint?: string;
+        /**
+         * Graph-determining request fields (endpoint, agent_id, model, spec, promptPrefix,
+         * ephemeralAgent) captured at pause. The resume route REPLAYS these onto the request
+         * before rebuilding the run, so a reload/cross-replica resume — where the client can
+         * no longer reconstruct the ephemeral config — still rebuilds the same agent/graph.
+         */
+        resumeContext?: Record<string, unknown>;
+    }
+    /**
+     * Scope of a tool-approval decision — drives the "remember this" persistence
+     * envelope. Storage of session/always decisions is a Slice B+ concern; the
+     * field is on the wire today so route signatures don't break later.
+     */
+    type DecisionScope = 'once' | 'session' | 'always';
+    /**
+     * Per-tool decision returned from the approval UI.
+     * Wire format. The host adapts each entry to the SDK's discriminated
+     * `ToolApprovalDecision` (e.g. `{ type: 'edit', updatedInput }`) at the resume route.
+     *
+     * Constraints:
+     * - `editedArguments` is required when `decision === 'edit'`.
+     * - `responseText` is required when `decision === 'respond'`.
+     * - `reason` is optional metadata; useful for reject/edit audit trails.
+     * - `scope` defaults to `'once'`.
+     */
+    interface ToolApprovalResolution {
+        tool_call_id: string;
+        decision: ToolApprovalDecisionType;
+        editedArguments?: Record<string, unknown>;
+        responseText?: string;
+        reason?: string;
+        scope?: DecisionScope;
+    }
+    /** Wire format for an ask-user-question response. */
+    interface AskUserQuestionResolution {
+        answer: string;
+    }
+    /** Wire format for a batched ask-user-question response. */
+    interface AskUserQuestionsResolution {
+        answers: Record<string, string>;
+    }
     interface ExtendedMessageContent {
         type?: string;
         text?: string;

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

@@ -1,5 +1,5 @@
 import type { OpenAPIV3 } from 'openapi-types';
-import type { AssistantsEndpoint, AgentProvider } from 'src/schemas';
+import type { AssistantsEndpoint, AgentProvider, MemoryScope } from 'src/schemas';
 import type { Agents, GraphEdge } from './agents';
 import type { ContentTypes } from './runs';
 import type { TFile } from './files';
@@ -188,6 +188,9 @@ export type SupportContact = {
     name?: string;
     email?: string;
 };
+export type AgentOwnerContact = {
+    name?: string;
+};
 /**
  * Specifies who can invoke a tool.
  * - 'direct': LLM can call directly
@@ -211,6 +214,21 @@ export type ToolOptions = {
      * @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.
@@ -255,12 +273,28 @@ export type Agent = {
     edges?: GraphEdge[];
     end_after_tools?: boolean;
     hide_sequential_outputs?: boolean;
+    /** Per-agent opt-in for stateful code sessions (requires the app-level capability). */
+    stateful_code_sessions?: boolean;
     artifacts?: ArtifactModes;
     recursion_limit?: number;
     isPublic?: boolean;
+    /**
+     * Whether the requesting user holds EDIT on this agent, so a single VIEW-scoped fetch can
+     * serve consumers that only need the editable subset instead of issuing a second full
+     * paginated walk under an EDIT-scoped cache key.
+     *
+     * Set by the list endpoint only; single-agent responses omit it. Treat absence as unknown
+     * and fail open (`isEditable !== false`), never as `false`, since a client on an older
+     * server would otherwise see an empty list rather than too many rows.
+     *
+     * Reflects the caller's ACL grant. The `MANAGE_AGENTS` capability bypasses ACL on write,
+     * so a capability holder can edit agents this flag reports as not editable.
+     */
+    isEditable?: boolean;
     version?: number;
     category?: string;
     support_contact?: SupportContact;
+    owner_contact?: AgentOwnerContact;
     /** Per-tool configuration options (deferred loading, allowed callers, etc.) */
     tool_options?: AgentToolOptions;
     /** Optional allowlist of skill ObjectIds. Only applies when `skills_enabled`. */
@@ -270,6 +304,8 @@ export type Agent = {
     skills_enabled?: boolean;
     /** Subagent spawning configuration — isolated-context child agents. */
     subagents?: AgentSubagentsConfig;
+    /** Memory partition: `agent` isolates memories per (user, agent); default shared pool */
+    memory_scope?: MemoryScope;
 };
 export type TAgentsMap = Record<string, Agent | undefined>;
 export type AgentCreateParams = {
@@ -282,7 +318,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' | 'skills' | 'skills_enabled' | 'subagents'>;
+} & Pick<Agent, 'agent_ids' | 'edges' | 'end_after_tools' | 'hide_sequential_outputs' | 'stateful_code_sessions' | 'artifacts' | 'recursion_limit' | 'category' | 'support_contact' | 'tool_options' | 'skills' | 'skills_enabled' | 'subagents' | 'memory_scope'>;
 export type AgentUpdateParams = {
     name?: string | null;
     description?: string | null;
@@ -294,7 +330,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' | 'skills' | 'skills_enabled' | 'subagents'>;
+} & Pick<Agent, 'agent_ids' | 'edges' | 'end_after_tools' | 'hide_sequential_outputs' | 'stateful_code_sessions' | 'artifacts' | 'recursion_limit' | 'category' | 'support_contact' | 'tool_options' | 'skills' | 'skills_enabled' | 'subagents' | 'memory_scope'>;
 export type AgentListParams = {
     limit?: number;
     requiredPermission: number;
@@ -476,6 +512,23 @@ export type SummaryContentPart = {
         contentIndex: number;
     };
 };
+/**
+ * A user steering message injected mid-run at a tool-batch boundary.
+ * Persisted inline in the response message's content array (keyed by the
+ * type name like `text`/`think` so token counting reads it for free);
+ * replayed as a user message on subsequent turns by `formatAgentMessages`.
+ */
+export type SteerContentPart = {
+    type: ContentTypes.STEER;
+    steer: string;
+    steerId?: string;
+    /** Stable optimistic-client id used to settle a POST whose response was lost. */
+    clientSteerId?: string;
+    createdAt?: number;
+    /** Attachments steered with the message; re-encoded per turn on replay
+     *  like any other user-message media (refs only, never encoded data). */
+    files?: Partial<TFile>[];
+};
 export type TMessageContentParts = ({
     type: ContentTypes.ERROR;
     text?: string | TextData;
@@ -483,17 +536,36 @@ export type TMessageContentParts = ({
 } & ContentMetadata) | ({
     type: ContentTypes.THINK;
     think?: string | TextData;
-} & ContentMetadata) | ({
+} & ContentMetadata) | (SteerContentPart & ContentMetadata) | ({
     type: ContentTypes.TEXT;
     text?: string | TextData;
     tool_call_ids?: string[];
+    /** Open Responses semantic channel for assistant text. */
+    phase?: 'commentary' | 'final_answer';
 } & ContentMetadata) | ({
     type: ContentTypes.TOOL_CALL;
     tool_call: (CodeToolCall | RetrievalToolCall | FileSearchToolCall | FunctionToolCall | Agents.AgentToolCall) & PartMetadata;
 } & ContentMetadata) | ({
     type: ContentTypes.IMAGE_FILE;
     image_file: ImageFile & PartMetadata;
-} & ContentMetadata) | (SummaryContentPart & ContentMetadata) | (Agents.AgentUpdate & ContentMetadata) | (Agents.MessageContentImageUrl & ContentMetadata) | (Agents.MessageContentVideoUrl & ContentMetadata) | (Agents.MessageContentInputAudio & ContentMetadata);
+} & ContentMetadata) | (SummaryContentPart & ContentMetadata) | ({
+    /** One-line LLM-generated note describing a completed tool batch. UI-only:
+     *  never sent to the model (stripped before payload formatting). */
+    type: ContentTypes.ACTIVITY_LABEL;
+    activity_label?: string;
+    /** Missing means the legacy/per-batch activity label. */
+    activity_label_type?: 'phase';
+    tool_call_ids?: string[];
+    /** Parent phase bounds and telemetry. */
+    activity_start_index?: number;
+    /** Exclusive end of the grouped content; may precede the marker itself. */
+    activity_end_index?: number;
+    activity_count?: number;
+    agent_ids?: string[];
+    /** ok = all tools succeeded, failed = all failed, partial = mixed. */
+    status?: 'ok' | 'partial' | 'failed';
+    pending?: boolean;
+} & ContentMetadata) | (Agents.AgentUpdate & ContentMetadata) | (Agents.MessageContentImageUrl & ContentMetadata) | (Agents.MessageContentVideoUrl & ContentMetadata) | (Agents.MessageContentInputAudio & ContentMetadata);
 export type StreamContentData = TMessageContentParts & {
     /** The index of the current content part */
     index: number;

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

@@ -1,5 +1,5 @@
-import { EToolResources } from './assistants';
 import type { CodeEnvRef } from '../codeEnvRef';
+import { EToolResources } from './assistants';
 export declare enum FileSources {
     local = "local",
     firebase = "firebase",
@@ -34,12 +34,16 @@ export declare enum FileContext {
     context = "context",
     bytes = "bytes"
 }
+/** Structural type for a compiled matcher: a native `RegExp` or a linear-time engine both satisfy it. Only `test` is ever called on `supportedMimeTypes`. */
+export type RegexLike = {
+    test(input: string): boolean;
+};
 export type EndpointFileConfig = {
     disabled?: boolean;
     fileLimit?: number;
     fileSizeLimit?: number;
     totalSizeLimit?: number;
-    supportedMimeTypes?: RegExp[];
+    supportedMimeTypes?: RegexLike[];
 };
 export type FileConfig = {
     endpoints: {
@@ -58,15 +62,15 @@ export type FileConfig = {
         quality?: number;
     };
     ocr?: {
-        supportedMimeTypes?: RegExp[];
+        supportedMimeTypes?: RegexLike[];
     };
     text?: {
-        supportedMimeTypes?: RegExp[];
+        supportedMimeTypes?: RegexLike[];
     };
     stt?: {
-        supportedMimeTypes?: RegExp[];
+        supportedMimeTypes?: RegexLike[];
     };
-    checkType?: (fileType: string, supportedTypes: RegExp[]) => boolean;
+    checkType?: (fileType: string, supportedTypes: RegexLike[]) => boolean;
 };
 export type FileConfigInput = {
     endpoints?: {
@@ -92,7 +96,7 @@ export type FileConfigInput = {
     stt?: {
         supportedMimeTypes?: string[];
     };
-    checkType?: (fileType: string, supportedTypes: RegExp[]) => boolean;
+    checkType?: (fileType: string, supportedTypes: RegexLike[]) => boolean;
 };
 export type TFile = {
     _id?: string;
@@ -217,6 +221,13 @@ export type VoiceOptions = {
     onMutate?: () => void | Promise<unknown>;
     onError?: (error: unknown, variables: unknown, context?: unknown) => void;
 };
+export type TFilesUsageBody = {
+    file_ids: string[];
+};
+export type TFilesUsageResponse = {
+    /** Count of queued uploads whose TTL hold was extended. */
+    held: number;
+};
 export type DeleteFilesResponse = {
     message: string;
     result: Record<string, unknown>;

package/dist/types/types/mcpServers.d.ts

@@ -39,5 +39,30 @@ export type MCPServerDBObjectResponse = {
     serverName: string;
     /** True if access is only via agent (not directly shared with user) */
     consumeOnly?: boolean;
+    /** True when chat request fields are required before the server can connect. */
+    requestScoped?: boolean;
 } & MCPOptions;
 export type MCPServersListResponse = Record<string, MCPServerDBObjectResponse>;
+export type MCPReinitializeFailureReason = 'unreachable' | 'missing_custom_user_vars' | 'oauth_required' | 'initialization_failed';
+export interface MCPReinitializeResponse {
+    success: boolean;
+    message: string;
+    serverName: string;
+    oauthRequired?: boolean;
+    oauthUrl?: string | null;
+    /** Shared OAuth attempt identifier used to poll durable flow state. */
+    flowId?: string;
+    /** Remaining OAuth completion window for this attempt, in milliseconds. */
+    oauthTimeout?: number;
+    failureReason?: MCPReinitializeFailureReason;
+    missingUserVars?: string[];
+    /** True when the server uses request-scoped placeholders and the connection
+     *  was deferred to the next chat turn (tools are not enumerable up front). */
+    connectionDeferred?: boolean;
+}
+export interface MCPOAuthStatusResponse {
+    status: 'PENDING' | 'COMPLETED' | 'FAILED';
+    completed: boolean;
+    failed: boolean;
+    error?: string;
+}

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

@@ -114,6 +114,7 @@ export type ArchiveConversationOptions = MutationOptions<types.TArchiveConversat
 export type PinConversationOptions = MutationOptions<types.TPinConversationResponse, types.TPinConversationRequest>;
 export type DuplicateConvoOptions = MutationOptions<types.TDuplicateConvoResponse, types.TDuplicateConvoRequest>;
 export type ForkConvoOptions = MutationOptions<types.TForkConvoResponse, types.TForkConvoRequest>;
+export type ForkSharedConvoOptions = MutationOptions<types.TForkConvoResponse, types.TForkSharedConvoRequest>;
 export type CreateSharedLinkOptions = MutationOptions<types.TSharedLink, Partial<types.TSharedLink>>;
 export type updateTagsInConvoOptions = MutationOptions<types.TTagConversationResponse, types.TTagConversationRequest>;
 export type UpdateSharedLinkOptions = MutationOptions<types.TSharedLink, Partial<types.TSharedLink>>;

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

@@ -64,7 +64,7 @@ export interface SharedLinksListParams {
 export type SharedLinkItem = {
     shareId: string;
     title: string;
-    createdAt: Date;
+    createdAt: string;
     conversationId: string;
 };
 export interface SharedLinksResponse {
@@ -120,6 +120,10 @@ export type TUserMemory = {
     value: string;
     updated_at: string;
     tokenCount?: number;
+    /** Agent partition this memory belongs to; absent = shared personal pool */
+    agentId?: string;
+    /** Display name of the partition's agent, resolved server-side when available */
+    agentName?: string;
 };
 export type MemoriesResponse = {
     memories: TUserMemory[];
@@ -163,6 +167,7 @@ export type ListRolesResponse = {
 export interface MCPServerStatus {
     requiresOAuth: boolean;
     connectionState: 'disconnected' | 'connecting' | 'connected' | 'error';
+    authorizationState?: 'not_required' | 'authorizing' | 'authorized' | 'needs_authorization' | 'error';
 }
 export interface MCPConnectionStatusResponse {
     success: boolean;
@@ -175,6 +180,7 @@ export interface MCPServerConnectionStatusResponse {
     serverName: string;
     requiresOAuth: boolean;
     connectionStatus: 'disconnected' | 'connecting' | 'connected' | 'error';
+    authorizationState?: MCPServerStatus['authorizationState'];
 }
 export interface MCPAuthValuesResponse {
     success: boolean;
@@ -191,8 +197,16 @@ export type TUserFavorite = {
     model?: string;
     endpoint?: string;
     spec?: string;
-    /** Phase 2 — skill favoriting isn't persisted yet, but the shape is reserved. */
-    skillId?: string;
+};
+/**
+ * Tool favorites — starred marketplace items (built-in capabilities, plugin
+ * tools, MCP servers, skills). Identity is the compound (itemType, itemId)
+ * pair, matching the marketplace `itemKey` format `itemType:itemId`.
+ */
+export type TToolFavoriteType = 'builtin' | 'tool' | 'mcp' | 'skill';
+export type TToolFavorite = {
+    itemType: TToolFavoriteType;
+    itemId: string;
 };
 export type GraphTokenParams = {
     scopes: string;