librechat-data-provider 0.8.521 → 0.8.522

package/dist/types/stateful-code.d.ts

@@ -0,0 +1,7 @@
+export declare const STATEFUL_CODE_ENVIRONMENTS: readonly ["user", "agent-user", "conversation"];
+export type StatefulCodeEnvironment = (typeof STATEFUL_CODE_ENVIRONMENTS)[number];
+/** Resolve a deployment allowlist in stable UI order. An omitted value preserves
+ * the backward-compatible behavior where every environment is available. */
+export declare function resolveAllowedStatefulCodeEnvironments(configured?: readonly StatefulCodeEnvironment[] | null): StatefulCodeEnvironment[];
+/** Keep an allowed preference, otherwise select the first deployment-allowed scope. */
+export declare function resolveStatefulCodeEnvironment(preferred: StatefulCodeEnvironment | null | undefined, configured?: readonly StatefulCodeEnvironment[] | null): StatefulCodeEnvironment | undefined;

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

@@ -1,6 +1,6 @@
 import type { TTokenUsageEvent, TContextUsageEvent, TPendingSteer } from './runs';
-import type { FunctionToolCall, SummaryContentPart } from './assistants';
 import type { TAttachment, TPlugin } from 'src/schemas';
+import type { SummaryContentPart } from './assistants';
 import { StepTypes, ContentTypes, ToolCallTypes } from './runs';
 export declare namespace Agents {
     type MessageType = 'human' | 'ai' | 'generic' | 'system' | 'function' | 'tool' | 'remove';
@@ -52,16 +52,36 @@ export declare namespace Agents {
      * A call to a tool.
      */
     type ToolCall = {
-        /** Type ("tool_call") according to Assistants Tool Call Structure */
-        type: ToolCallTypes.TOOL_CALL;
+        /** Type ("tool_call") according to Assistants Tool Call Structure; optional literal
+         *  form included to mirror langchain's ToolCall, whose `type` is optional. */
+        type?: ToolCallTypes.TOOL_CALL | 'tool_call';
         /** The name of the tool to be called */
         name: string;
+        /** Host-derived MCP server identity retained to disambiguate historical tool keys. */
+        mcpServerName?: string;
         /** The arguments to the tool call */
         args?: string | Record<string, any>;
         /** If provided, an identifier associated with the tool call */
         id?: string;
+        /** Host run-step identity; unlike provider ids, this is unique across turns. */
+        stepId?: string;
         /** If provided, the output of the tool call */
         output?: string;
+        /** Host-owned durable receipt for a detached ordinary tool result.
+         * It lives beside the original call so reload, manual collection, and
+         * automatic continuation all arbitrate the same result identity. */
+        backgroundTask?: {
+            version: 1;
+            taskId: string;
+            toolName: string;
+            status: 'completed' | 'error';
+            settledAt: Date;
+            resultClaim?: {
+                kind: 'manual' | 'wakeup';
+                claimId: string;
+                claimedAt: Date;
+            };
+        };
         /** The tool call was rejected before execution because its input failed schema validation. */
         inputValidationError?: true;
         /** Auth URL */
@@ -177,7 +197,35 @@ export declare namespace Agents {
         groupId?: number;
         stepDetails: StepDetails;
         summary?: SummaryContentPart;
-        usage: null | object;
+        /** Optional to mirror the agents SDK, which omits usage until a step reports it. */
+        usage?: null | object;
+        /** Epoch ms the step was opened. Emitted by `@librechat/agents` >= 3.4.6. */
+        created_at?: number;
+        status?: RunStepStatus;
+    };
+    /** Lifecycle status of a run step. `in_progress` until a terminal close. */
+    type RunStepStatus = 'in_progress' | 'completed' | 'cancelled' | 'failed';
+    /** Terminal status a run step can close with. */
+    type RunStepClosedStatus = Exclude<RunStepStatus, 'in_progress'>;
+    /**
+     * Payload of {@link StepEvents.ON_RUN_STEP_CLOSED}. Emitted once per step
+     * when it reaches a terminal state, including steps swept at end-of-run
+     * because the caller aborted — which is the only signal that distinguishes
+     * a stopped step from one still in flight.
+     */
+    type RunStepClosedEvent = {
+        id: string;
+        index: number;
+        type: StepTypes;
+        status: RunStepClosedStatus;
+        /** Epoch ms the step was opened, when the emitter knows it. */
+        created_at?: number;
+        /** Epoch ms the step reached its terminal state. */
+        closed_at: number;
+        runId?: string;
+        agentId?: string;
+        groupId?: number;
+        stepIndex?: number;
     };
     /** Content part for aggregated message content */
     interface ContentPart {
@@ -197,6 +245,16 @@ export declare namespace Agents {
         manualSkills?: string[];
         alwaysAppliedSkills?: string[];
     }
+    /** Client-safe state for one MCP authorization prompt that remains actionable. */
+    interface PendingMCPOAuthPrompt {
+        stepId: string;
+        runId?: string;
+        index: number;
+        toolCallId?: string;
+        toolName: string;
+        authURL: string;
+        expiresAt?: number;
+    }
     /** State data sent to reconnecting clients */
     interface ResumeState {
         runSteps: RunStep[];
@@ -204,6 +262,8 @@ export declare namespace Agents {
         aggregatedContent?: MessageContentComplex[];
         userMessage?: UserMessageMeta;
         responseMessageId?: string;
+        /** True when the live generation replaces an existing assistant branch. */
+        isRegenerate?: boolean;
         conversationId?: string;
         sender?: string;
         iconURL?: string;
@@ -220,6 +280,8 @@ export declare namespace Agents {
             data?: unknown;
             [key: string]: unknown;
         }>;
+        /** Pending MCP authorization prompts projected from durable stream state. */
+        pendingOAuthPrompts?: PendingMCPOAuthPrompt[];
         /** Cumulative provider-reported usage for the run; backfills usage totals on resume */
         collectedUsage?: TTokenUsageEvent[];
         /** Latest context window snapshot; restores the usage gauge on resume */
@@ -263,7 +325,7 @@ export declare namespace Agents {
     };
     type ToolCallsDetails = {
         type: StepTypes.TOOL_CALLS;
-        tool_calls: AgentToolCall[];
+        tool_calls?: AgentToolCall[];
     };
     type ToolCallDelta = {
         type: StepTypes.TOOL_CALLS | string;
@@ -277,7 +339,21 @@ export declare namespace Agents {
             description?: string;
         };
     };
-    type AgentToolCall = FunctionToolCall | ToolCall;
+    /**
+     * Mirrors the agents SDK's function tool-call variant: `arguments` may arrive as a
+     * parsed object, and `output` is attached by LibreChat aggregation only once available
+     * (the legacy assistants `FunctionToolCall` requires both as string/present).
+     */
+    type AgentFunctionToolCall = {
+        id: string;
+        type: 'function';
+        function: {
+            name: string;
+            arguments: string | object;
+            output?: string | null;
+        };
+    };
+    type AgentToolCall = AgentFunctionToolCall | ToolCall;
     /**
      * Human-in-the-loop interrupt categories. The discriminator on
      * {@link HumanInterruptPayload}.
@@ -646,8 +722,17 @@ export type GraphEdge = {
      *
      * For handoff edges: Description for the input parameter that the handoff tool accepts,
      * allowing the supervisor to pass specific instructions/context to the transferred agent.
+     *
+     * The callback receives a minimal structural view of the run's messages (data-provider
+     * cannot depend on langchain's BaseMessage): every langchain message satisfies
+     * `{ content: unknown }`, and callbacks typed against richer structural message shapes
+     * remain assignable. The promise branch mirrors the agents SDK signature exactly —
+     * widening it (e.g. to `Promise<string | undefined>`) would break assignability of
+     * stored edges into the SDK's `GraphEdge`.
      */
-    prompt?: string | ((messages: BaseMessage[], runStartIndex: number) => string | undefined);
+    prompt?: string | ((messages: {
+        content: unknown;
+    }[], runStartIndex: number) => string | Promise<string> | undefined);
     /**
      * When true, excludes messages from startIndex when adding prompt.
      * Automatically set to true when {results} variable is used in prompt.

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

@@ -1,9 +1,12 @@
 import type { OpenAPIV3 } from 'openapi-types';
-import type { AssistantsEndpoint, AgentProvider, MemoryScope } from 'src/schemas';
+import type { AssistantsEndpoint, AgentProvider, MemoryScope, SkillsScope } from 'src/schemas';
+import type { StatefulCodeEnvironment } from '../stateful-code';
 import type { Agents, GraphEdge } from './agents';
 import type { ContentTypes } from './runs';
 import type { TFile } from './files';
 import { ArtifactModes } from 'src/artifacts';
+export { STATEFUL_CODE_ENVIRONMENTS, resolveStatefulCodeEnvironment, resolveAllowedStatefulCodeEnvironments, } from '../stateful-code';
+export type { StatefulCodeEnvironment } from '../stateful-code';
 export type Schema = OpenAPIV3.SchemaObject & {
     description?: string;
 };
@@ -238,14 +241,36 @@ 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`.
+ * to itself, listed single-agent targets, and/or explicit saved-agent teams.
  */
+export type AgentSubagentGraphEdge = Omit<GraphEdge, 'edgeType' | 'condition' | 'prompt' | 'promptKey'> & {
+    edgeType: 'direct';
+    condition?: never;
+    prompt?: string;
+    promptKey?: never;
+};
+/** A bounded saved-agent team that can be spawned as one isolated child graph. */
+export type AgentSubagentGraph = {
+    /** Stable spawn-tool enum value for the team. */
+    type: string;
+    name: string;
+    description: string;
+    /** Member IDs. In create/update payloads, an empty ID refers to the current agent. */
+    agent_ids: string[];
+    edges: AgentSubagentGraphEdge[];
+    /** Entry member ID. In create/update payloads, an empty ID refers to the current agent. */
+    entry_agent_id: string;
+    /** Result member ID. In create/update payloads, an empty ID refers to the current agent. */
+    result_agent_id: string;
+};
 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[];
+    /** Explicit saved-agent teams that may be spawned as bounded child graphs. */
+    graphs?: AgentSubagentGraph[];
 };
 export type Agent = {
     _id?: string;
@@ -275,6 +300,10 @@ export type Agent = {
     hide_sequential_outputs?: boolean;
     /** Per-agent opt-in for stateful code sessions (requires the app-level capability). */
     stateful_code_sessions?: boolean;
+    /** Stateful workspace sharing scope. Defaults to one workspace per user. */
+    stateful_code_environment?: StatefulCodeEnvironment;
+    /** Operator-configured managed or attached stateful execution environment. */
+    code_environment_id?: string | null;
     artifacts?: ArtifactModes;
     recursion_limit?: number;
     isPublic?: boolean;
@@ -297,11 +326,17 @@ export type Agent = {
     owner_contact?: AgentOwnerContact;
     /** Per-tool configuration options (deferred loading, allowed callers, etc.) */
     tool_options?: AgentToolOptions;
+    /** Attached action registrations, each `${encodedDomain}${actionDelimiter}${action_id}` */
+    actions?: string[];
     /** 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;
+    /** Enables runtime skill creation without exposing an existing skill catalog. */
+    skill_authoring_enabled?: boolean;
+    /** Explicit catalog exposure while skills are enabled. Missing preserves legacy semantics. */
+    skills_scope?: SkillsScope;
     /** Subagent spawning configuration — isolated-context child agents. */
     subagents?: AgentSubagentsConfig;
     /** Memory partition: `agent` isolates memories per (user, agent); default shared pool */
@@ -318,7 +353,7 @@ export type AgentCreateParams = {
     provider: AgentProvider;
     model: string | null;
     model_parameters: AgentModelParameters;
-} & 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'>;
+} & Pick<Agent, 'agent_ids' | 'edges' | 'end_after_tools' | 'hide_sequential_outputs' | 'stateful_code_sessions' | 'stateful_code_environment' | 'code_environment_id' | 'artifacts' | 'recursion_limit' | 'category' | 'support_contact' | 'tool_options' | 'skills' | 'skills_enabled' | 'skill_authoring_enabled' | 'skills_scope' | 'subagents' | 'memory_scope'>;
 export type AgentUpdateParams = {
     name?: string | null;
     description?: string | null;
@@ -330,7 +365,7 @@ export type AgentUpdateParams = {
     provider?: AgentProvider;
     model?: string | null;
     model_parameters?: AgentModelParameters;
-} & 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'>;
+} & Pick<Agent, 'agent_ids' | 'edges' | 'end_after_tools' | 'hide_sequential_outputs' | 'stateful_code_sessions' | 'stateful_code_environment' | 'code_environment_id' | 'artifacts' | 'recursion_limit' | 'category' | 'support_contact' | 'tool_options' | 'skills' | 'skills_enabled' | 'skill_authoring_enabled' | 'skills_scope' | 'subagents' | 'memory_scope'>;
 export type AgentListParams = {
     limit?: number;
     requiredPermission: number;
@@ -490,9 +525,46 @@ export type PartMetadata = {
     agentId?: string;
     /** Group ID for parallel content - parts with same groupId are displayed in columns */
     groupId?: number;
+    /**
+     * Terminal lifecycle status of the run step that produced this part, from
+     * `on_run_step_closed`. Distinct from `status`, which is already claimed by
+     * activity-label and question-form parts. Absent on parts predating the
+     * event or from endpoints that do not emit it, in which case renderers fall
+     * back to inferring "stopped" from `progress` and `isSubmitting`.
+     */
+    runStepStatus?: Agents.RunStepClosedStatus;
+    /**
+     * Wall-clock milliseconds the run step took, derived from the same
+     * `on_run_step_closed` event as {@link runStepStatus} via
+     * `getRunStepDurationMs`. Only written when the event carried both
+     * timestamps and they agree in order — so its absence means "not
+     * derivable", never "instant". The raw value is persisted unfiltered;
+     * whether it is worth showing (`isReportableRunStepDuration`) is decided
+     * at render time.
+     */
+    runStepDurationMs?: number;
+    /**
+     * Stamped by the background harvester when a detached task's final output
+     * replaces the dispatch handle in `tool_call.output`. The handle JSON and
+     * the live status-marker attachment are both transient, so after the patch
+     * (or a reload) this is the only signal that the call ran in the
+     * background — renderers use it to keep treating {@link runStepDurationMs}
+     * as dispatch time rather than the task's runtime.
+     */
+    backgrounded?: boolean;
+    /**
+     * Content index this part occupied while its run streamed. The aggregator
+     * writes parts at provider-source indexes, so the streamed array is sparse;
+     * persistence compacts it and every part after a hole shifts down. The
+     * client's final handler stamps the streamed position onto the compacted
+     * parts it adopts, so index-derived render identity survives the swap
+     * instead of remounting the settled message. Client-only and absent
+     * everywhere else — persisted content never carries it.
+     */
+    streamedIndex?: number;
 };
 /** Metadata for parallel content rendering - subset of PartMetadata */
-export type ContentMetadata = Pick<PartMetadata, 'agentId' | 'groupId'>;
+export type ContentMetadata = Pick<PartMetadata, 'agentId' | 'groupId' | 'streamedIndex'>;
 export type ContentPart = (CodeToolCall | RetrievalToolCall | FileSearchToolCall | FunctionToolCall | Agents.AgentToolCall | ImageFile | Text) & PartMetadata;
 export type TextData = (Text & PartMetadata) | undefined;
 export type SummaryContentPart = {
@@ -528,6 +600,10 @@ export type SteerContentPart = {
     /** 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>[];
+    /** Quoted excerpts steered with the message, persisted separately from the
+     *  typed text (mirroring `TMessage.quotes`) so the UI renders them as
+     *  reference blocks; merged into the model-bound user turn on every replay. */
+    quotes?: string[];
 };
 export type TMessageContentParts = ({
     type: ContentTypes.ERROR;
@@ -536,6 +612,21 @@ export type TMessageContentParts = ({
 } & ContentMetadata) | ({
     type: ContentTypes.THINK;
     think?: string | TextData;
+    /** Generated orientation for this user-visible reasoning step. */
+    reasoning_label?: string;
+    /** Stable SDK run-step identity used to correlate live revisions. */
+    reasoning_label_step_id?: string;
+    /** Durable provider-call count used to enforce the per-run cost cap across resumes. */
+    reasoning_label_attempts?: number;
+    /** Visible reasoning length included in this step's latest provider call. */
+    reasoning_label_submitted_chars?: number;
+    /** Monotonic provider-call revision; gaps are allowed after unsuccessful attempts. */
+    reasoning_label_revision?: number;
+    /** Whether the reasoning step can still produce a newer label. */
+    reasoning_label_status?: 'streaming' | 'complete';
+    /** The reasoning happened but its text is not available to this view
+     *  (e.g. detached subagent projections retain only a marker). */
+    reasoning_unavailable?: boolean;
 } & ContentMetadata) | (SteerContentPart & ContentMetadata) | ({
     type: ContentTypes.TEXT;
     text?: string | TextData;

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

@@ -1,4 +1,4 @@
-import type { CodeEnvRef } from '../codeEnvRef';
+import type { CodeEnvRef, CodeEnvRefMap } from '../codeEnvRef';
 import { EToolResources } from './assistants';
 export declare enum FileSources {
     local = "local",
@@ -60,6 +60,8 @@ export type FileConfig = {
         maxWidth?: number;
         maxHeight?: number;
         quality?: number;
+        /** Set when `enabled` came from the admin config, in which case it wins over the user's setting */
+        enforced?: boolean;
     };
     ocr?: {
         supportedMimeTypes?: RegexLike[];
@@ -155,6 +157,9 @@ export type TFile = {
          * resolve via `resolveCodeEnvRef`.
          */
         codeEnvRef?: CodeEnvRef;
+        codeEnvRefs?: CodeEnvRefMap;
+        /** Dispatch-order stamp for the current source artifact generation. */
+        sourceDispatchedAt?: number;
     };
     createdAt?: string | Date;
     updatedAt?: string | Date;
@@ -230,7 +235,9 @@ export type TFilesUsageResponse = {
 };
 export type DeleteFilesResponse = {
     message: string;
-    result: Record<string, unknown>;
+    result?: Record<string, unknown>;
+    deletedFileIds?: string[];
+    failedFileIds?: string[];
 };
 export type BatchFile = {
     file_id: string;
@@ -251,4 +258,7 @@ export type DeleteMutationOptions = {
     onSuccess?: (data: DeleteFilesResponse, variables: DeleteFilesBody, context?: unknown) => void;
     onMutate?: (variables: DeleteFilesBody) => void | Promise<unknown>;
     onError?: (error: unknown, variables: DeleteFilesBody, context?: unknown) => void;
+    /** Suppresses the result toasts. Background cleanup runs on a timer the user never asked for,
+     * and a storage failure that keeps failing would otherwise announce itself on every retry. */
+    silent?: boolean;
 };

package/dist/types/types/index.d.ts

@@ -1,2 +1,4 @@
 export * from './queries';
 export * from './mcpServers';
+export * from './subagents';
+export * from './queuedTurns';

package/dist/types/types/insights.d.ts

@@ -0,0 +1,62 @@
+export type InsightsRange = '24h' | '7d' | '30d' | 'custom';
+export declare const INSIGHTS_MAX_RANGE_DAYS = 30;
+export declare const INSIGHTS_SEARCH_MIN_LENGTH = 3;
+export declare const INSIGHTS_SEARCH_MAX_LENGTH = 200;
+export type TInsightsParams = {
+    range?: InsightsRange;
+    fromTimestamp?: string;
+    toTimestamp?: string;
+    timeZone?: string;
+    search?: string;
+    page?: number;
+    pageSize?: number;
+};
+export type TInsightsDailyPoint = {
+    date: string;
+    conversations: number;
+    users: number;
+    messages: number;
+    totalTokens: number;
+};
+export type TInsightsUser = {
+    userId: string;
+    name: string;
+    email: string;
+    conversations: number;
+    messages: number;
+};
+export type TInsightsChurnedUser = TInsightsUser & {
+    firstSeen: string;
+    lastSeen: string;
+};
+export type TInsightsConversation = {
+    conversationId: string;
+    date: string;
+    userId: string;
+    name: string;
+    email: string;
+    firstMessage: string;
+    messages: number;
+    totalTokens: number;
+};
+export type TInsightsSummary = {
+    totalUsers: number;
+    totalConversations: number;
+    totalMessages: number;
+    totalTokens: number;
+};
+export type TInsightsResponse = {
+    summary: TInsightsSummary;
+    daily: TInsightsDailyPoint[];
+    topUsers: TInsightsUser[];
+    churnedUsers: TInsightsChurnedUser[];
+    latest: {
+        conversations: TInsightsConversation[];
+        page: number;
+        pageSize: number;
+        pages: number;
+    };
+};
+export type TInsightsAccessResponse = {
+    access: boolean;
+};

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

@@ -119,6 +119,7 @@ export type CreateSharedLinkOptions = MutationOptions<types.TSharedLink, Partial
 export type updateTagsInConvoOptions = MutationOptions<types.TTagConversationResponse, types.TTagConversationRequest>;
 export type UpdateSharedLinkOptions = MutationOptions<types.TSharedLink, Partial<types.TSharedLink>>;
 export type ArchiveConvoOptions = MutationOptions<types.TArchiveConversationResponse, types.TArchiveConversationRequest>;
+export type ArchiveAllConversationsOptions = MutationOptions<types.TArchiveAllConversationsResponse, void>;
 export type DeleteSharedLinkContext = {
     previousQueries?: Map<string, TDeleteSharedLinkResponse>;
 };

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

@@ -1,4 +1,5 @@
 import type { InfiniteData } from '@tanstack/react-query';
+import type { RerankerTypes, SearchProviders, ScraperProviders } from '../config';
 import type * as p from '../accessPermissions';
 import type * as a from '../types/agents';
 import type * as s from '../schemas';
@@ -12,14 +13,16 @@ export type Conversation = {
 };
 export type ConversationListParams = {
     cursor?: string;
+    limit?: number;
     isArchived?: boolean;
-    sortBy?: 'title' | 'createdAt' | 'updatedAt';
+    pinned?: boolean;
+    sortBy?: 'title' | 'createdAt' | 'updatedAt' | 'archivedAt';
     sortDirection?: 'asc' | 'desc';
     tags?: string[];
     search?: string;
     projectId?: string;
 };
-export type MinimalConversation = Pick<s.TConversation, 'conversationId' | 'endpoint' | 'title' | 'createdAt' | 'updatedAt' | 'user' | 'chatProjectId'>;
+export type MinimalConversation = Pick<s.TConversation, 'conversationId' | 'endpoint' | 'title' | 'createdAt' | 'updatedAt' | 'archivedAt' | 'user' | 'chatProjectId' | 'pinned'>;
 export type ConversationListResponse = {
     conversations: MinimalConversation[];
     nextCursor: string | null;
@@ -92,6 +95,9 @@ export type MCPTool = {
     name: string;
     pluginKey: string;
     description: string;
+    /** Raw upstream tool name when the model-facing key stripped a redundant
+     *  server-name prefix — gates the agent editor's legacy id migration. */
+    serverToolName?: string;
 };
 export type MCPServer = {
     name: string;
@@ -110,20 +116,29 @@ export type VerifyToolAuthResponse = {
     authenticated: boolean;
     message?: string | s.AuthType;
     authTypes?: [string, s.AuthType][];
+    searchProvider?: SearchProviders;
+    scraperProvider?: ScraperProviders;
+    rerankerType?: RerankerTypes;
 };
 export type GetToolCallParams = {
     conversationId: string;
 };
 export type ToolCallResults = a.ToolCallResult[];
 export type TUserMemory = {
+    /** Stable stored record identifier retained when content fields are redacted. */
+    _id?: string;
     key: string;
     value: string;
+    /** Optional generated or legacy summary content. */
+    summary?: 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;
+    /** Current policy removed one or more memory content fields from this response. */
+    contentFilterBlocked?: boolean;
 };
 export type MemoriesResponse = {
     memories: TUserMemory[];
@@ -131,6 +146,13 @@ export type MemoriesResponse = {
     tokenLimit: number | null;
     usagePercentage: number | null;
 };
+export type UpdateMemoryResponse = {
+    updated: boolean;
+    memory: TUserMemory;
+};
+export type DeleteMemoryResponse = {
+    deleted: boolean;
+};
 export type PrincipalSearchParams = {
     q: string;
     limit?: number;
@@ -166,6 +188,10 @@ export type ListRolesResponse = {
 };
 export interface MCPServerStatus {
     requiresOAuth: boolean;
+    /** The server connects only inside a chat request because its config reads BODY placeholders. */
+    requestScoped?: boolean;
+    /** Whether all declared per-user variables are present for an on-demand connection. */
+    configurationState?: 'configured' | 'needs_configuration';
     connectionState: 'disconnected' | 'connecting' | 'connected' | 'error';
     authorizationState?: 'not_required' | 'authorizing' | 'authorized' | 'needs_authorization' | 'error';
 }
@@ -179,6 +205,8 @@ export interface MCPServerConnectionStatusResponse {
     success: boolean;
     serverName: string;
     requiresOAuth: boolean;
+    requestScoped?: boolean;
+    configurationState?: MCPServerStatus['configurationState'];
     connectionStatus: 'disconnected' | 'connecting' | 'connected' | 'error';
     authorizationState?: MCPServerStatus['authorizationState'];
 }