librechat-data-provider 0.8.509 → 0.8.522

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

@@ -1,3 +1,4 @@
+import type { TFile } from './files';
 export declare enum ContentTypes {
     TEXT = "text",
     THINK = "think",
@@ -9,6 +10,8 @@ export declare enum ContentTypes {
     INPUT_AUDIO = "input_audio",
     AGENT_UPDATE = "agent_update",
     SUMMARY = "summary",
+    ACTIVITY_LABEL = "activity_label",
+    STEER = "steer",
     ERROR = "error"
 }
 export declare enum StepTypes {
@@ -30,16 +33,191 @@ export declare enum StepEvents {
     ON_REASONING_DELTA = "on_reasoning_delta",
     ON_RUN_STEP_DELTA = "on_run_step_delta",
     ON_RUN_STEP_COMPLETED = "on_run_step_completed",
+    /** Terminal signal for a run step: closed with a status and timestamps. */
+    ON_RUN_STEP_CLOSED = "on_run_step_closed",
     ON_SUMMARIZE_START = "on_summarize_start",
     ON_SUMMARIZE_DELTA = "on_summarize_delta",
     ON_SUMMARIZE_COMPLETE = "on_summarize_complete",
-    ON_SUBAGENT_UPDATE = "on_subagent_update"
+    ON_SUBAGENT_UPDATE = "on_subagent_update",
+    ON_SANDBOX_STARTING = "on_sandbox_starting",
+    ON_PTC_TOOL_CALL = "on_ptc_tool_call"
 }
+/** Payload for {@link StepEvents.ON_SANDBOX_STARTING} — the stateful code
+ * sandbox is cold-booting for the given code tool call. */
+export type SandboxStartingEvent = {
+    tool_call_id: string;
+    runId?: string;
+};
+/** Lifecycle of one tool call made from inside a programmatic (PTC) program. */
+export type PtcToolCallStatus = 'running' | 'success' | 'error';
+/**
+ * Payload for {@link StepEvents.ON_PTC_TOOL_CALL} — one tool invocation the
+ * sandbox made on behalf of a programmatic tool-calling program. Emitted twice
+ * per inner call (`running`, then `success` / `error`) so the PTC card can
+ * render a live trace of what the code is doing under the code itself.
+ */
+export type PtcToolCallEvent = {
+    /** The PTC run step's tool call id — the card this line belongs under. */
+    tool_call_id: string;
+    /** Stable per-program id; the settle event reuses the start event's value. */
+    call_id: string;
+    /** Inner tool id, e.g. `search_code_mcp_github`. */
+    name: string;
+    status: PtcToolCallStatus;
+    /** `key=value` preview of the call's input. Start event only. */
+    args?: string;
+    /** Truncated failure message. `error` status only. */
+    error?: string;
+    /** Wall-clock time the inner call took. Settle events only. */
+    durationMs?: number;
+    runId?: string;
+};
 /** Token-tracking event names streamed to the client (separate from StepEvents dispatch). */
 export declare enum UsageEvents {
     ON_CONTEXT_USAGE = "on_context_usage",
     ON_TOKEN_USAGE = "on_token_usage"
 }
+/**
+ * Human-in-the-loop event names. Streamed to live clients when a run pauses for
+ * tool approval (or an ask-user question). Reconnecting clients instead read the
+ * same record from `resumeState.pendingAction` on the sync event / status route.
+ */
+export declare enum ApprovalEvents {
+    ON_PENDING_ACTION = "on_pending_action"
+}
+/**
+ * Steering event names. `on_steer_applied` streams to live clients when a
+ * queued steer message is injected at a tool-batch boundary; reconnecting
+ * clients recover injected steers from `aggregatedContent` and still-queued
+ * ones from `resumeState.pendingSteers`. Steers that never reach a boundary
+ * ride the final/abort events as `pendingSteers`.
+ */
+export declare enum SteerEvents {
+    ON_STEER_APPLIED = "on_steer_applied",
+    /** Durable capability correction for queued steers after HITL handover. */
+    ON_STEER_UPDATED = "on_steer_updated"
+}
+/**
+ * Activity-label event names. `on_activity_label` streams to live clients
+ * when a tool-batch or parent-phase label part is claimed and again when the
+ * fast-model label resolves; reconnecting clients recover applied labels
+ * from `aggregatedContent` like any other content part.
+ */
+export declare enum ActivityLabelEvents {
+    ON_ACTIVITY_LABEL = "on_activity_label"
+}
+/** Live title updates for an existing reasoning content part. */
+export declare enum ReasoningLabelEvents {
+    ON_REASONING_LABEL = "on_reasoning_label",
+    /** Internal durable budget reservation; clients intentionally do not render it. */
+    ON_REASONING_LABEL_ATTEMPT = "on_reasoning_label_attempt"
+}
+type TReasoningLabelEventBase = {
+    /** Completion-local content index of the reasoning part being updated. */
+    index: number;
+    stepId: string;
+    responseMessageId?: string;
+    conversationId?: string;
+};
+/** Payload of the `on_reasoning_label` SSE event. */
+export type TReasoningLabelEvent = TReasoningLabelEventBase & ({
+    /** Clears a snapshot title when its THINK slot changed during the resume gap. */
+    reset: true;
+    /** Step identity observed in the snapshot and exclusively eligible for this reset. */
+    previousStepId: string;
+    /** Latest run-global call-budget high-water, when present on fresh content. */
+    attempts?: number;
+} | {
+    reset?: false;
+    /** Run-unique provider-call revision; may contain gaps after unsuccessful attempts. */
+    revision: number;
+    label: string;
+    status: 'streaming' | 'complete';
+});
+/** Durable run-cumulative call-budget reservation, attributed to one reasoning step. */
+export type TReasoningLabelAttemptEvent = {
+    index: number;
+    stepId: string;
+    attempts: number;
+    submittedChars: number;
+};
+/** Payload of the `on_activity_label` SSE event. */
+export type TActivityLabelEvent = {
+    /** Absolute content index the label part occupies. */
+    index: number;
+    part: {
+        type: ContentTypes.ACTIVITY_LABEL;
+        [ContentTypes.ACTIVITY_LABEL]: string;
+        /** Missing means a per-batch activity label. */
+        activity_label_type?: 'phase';
+        tool_call_ids?: string[];
+        activity_start_index?: number;
+        activity_end_index?: number;
+        activity_count?: number;
+        agent_ids?: string[];
+        counts?: {
+            searches: number;
+            reads: number;
+            writes: number;
+            commands: number;
+            other: number;
+        };
+        status?: 'ok' | 'partial' | 'failed';
+        agentId?: string;
+        pending?: boolean;
+    };
+    responseMessageId?: string;
+    conversationId?: string;
+};
+/** A steer message queued server-side but not yet injected into the run. */
+export type TPendingSteer = {
+    steerId: string;
+    /** Correlates a server steer with its optimistic chip when terminal delivery
+     *  races ahead of the POST response. */
+    clientSteerId?: string;
+    text: string;
+    createdAt?: number;
+    files?: Partial<TFile>[];
+    /** Quoted excerpts steered with the message ("Add to chat" selections);
+     *  merged into the model-bound text at the injection boundary. */
+    quotes?: string[];
+    /** The steer asked to interrupt generation at the next safe boundary —
+     *  kept on parked/replayed chips so the "interrupting" label survives. */
+    preempt?: boolean;
+    /** Monotonic server revision for last-writer-wins interrupt labels. */
+    preemptRevision?: number;
+};
+/** Payload of the `on_steer_applied` SSE event. */
+export type TSteerAppliedEvent = {
+    steerId: string;
+    /** Correlates the applied event with the optimistic chip before the POST settles. */
+    clientSteerId?: string;
+    /** Absolute content index the steer part was injected at. */
+    index: number;
+    part: {
+        type: ContentTypes.STEER;
+        [ContentTypes.STEER]: string;
+        steerId?: string;
+        clientSteerId?: string;
+        createdAt?: number;
+        files?: Partial<TFile>[];
+        /** Quoted excerpts steered with the message (mirrors `SteerContentPart`,
+         *  which cannot be imported here without a module cycle). */
+        quotes?: string[];
+    };
+    responseMessageId?: string;
+    conversationId?: string;
+};
+/** A queued steer's interrupt label changed without moving its FIFO slot. */
+export type TSteerUpdatedEvent = {
+    conversationId: string;
+    steers: Array<{
+        steerId: string;
+        clientSteerId?: string;
+        preempt: boolean;
+        preemptRevision: number;
+    }>;
+};
 /** Mirrors TokenBudgetBreakdown from @librechat/agents (data-provider cannot import it). */
 export type TTokenBudgetBreakdown = {
     maxContextTokens: number;
@@ -78,28 +256,6 @@ export type TContextUsageEvent = {
      *  already includes for earlier steps. */
     completedOutputTokens?: number;
 };
-/**
- * Request payload for a server-side context-usage projection: "what context
- * would the next call send for this branch under this config", computed by the
- * agents SDK without invoking the model. Powers the gauge in states the live
- * snapshot can't cover (page load of a snapshot-less branch, window/model
- * switch). `messageId` is the viewed branch's tail; the server walks its parent
- * chain.
- */
-export type TContextProjectionRequest = {
-    conversationId: string;
-    messageId: string;
-    endpoint: string;
-    model?: string;
-    agentId?: string;
-    spec?: string;
-    maxContextTokens?: number;
-    /** Provider-calibrated ratio from a prior snapshot, applied as a static seed. */
-    calibrationRatio?: number;
-    /** Client-only cache-bust: a branch content revision so a message edit
-     *  (which keeps the same tail id) refetches. The server ignores it. */
-    revision?: number;
-};
 /**
  * Per-response usage rollup persisted on `responseMessage.metadata.usage`, in
  * display units (input excludes cache; output includes repaired completion).
@@ -128,8 +284,10 @@ export type TTokenUsageEvent = {
     provider?: string;
     /** Non-primary buckets fold into session cost/totals but not the live
      *  context gauge: hidden sequential-agent calls (`sequential`), summary
-     *  passes (`summarization`), and isolated subagent runs (`subagent`) */
-    usage_type?: 'summarization' | 'subagent' | 'sequential';
+     *  passes (`summarization`), isolated subagent runs (`subagent`), and
+     *  fast-model activity headers (`activity-label`, `activity-phase`), and
+     *  live reasoning titles (`reasoning-label`) */
+    usage_type?: 'summarization' | 'subagent' | 'sequential' | 'activity-label' | 'activity-phase' | 'reasoning-label';
     runId?: string;
     /** Per-run emission sequence; keeps identical payloads from distinct model calls unique */
     seq?: number;
@@ -161,20 +319,42 @@ export declare const promptTokensFromUsage: (event: TTokenUsageEvent) => number;
  */
 export declare const reconcileContextUsage: (snapshot: TContextUsageEvent, promptTokens: number) => TContextUsageEvent;
 /** 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';
+export type SubagentUpdatePhase = 'start' | 'run_step' | 'run_step_delta' | 'run_step_completed' | 'run_step_closed' | 'message_delta' | 'reasoning_delta' | 'stop' | 'error';
+/** Structured root-to-leaf identity for one nested subagent execution. */
+export interface SubagentAncestryEntry {
+    readonly subagentRunId: string;
+    readonly subagentType: string;
+    readonly subagentKind: 'agent' | 'graph';
+    /** Execution subject ID; synthetic for graph subagents. */
+    readonly subagentAgentId: string;
+    readonly parentRunId: string;
+    readonly parentAgentId?: string;
+    readonly parentToolCallId?: string;
+}
 /** Single streamed subagent update forwarded by the SDK's SubagentExecutor. */
 export interface SubagentUpdateEvent {
     runId: string;
+    parentRunId?: string;
     subagentRunId: string;
+    /** Host-assigned identity preserved when one detached update overlaps delivery streams. */
+    activityEventId?: string;
+    /** Host-assigned monotonic sequence within one detached child run. */
+    activitySequence?: number;
     /** 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;
+    subagentKind?: 'agent' | 'graph';
+    /** Execution subject ID; synthetic for graph subagents. */
     subagentAgentId: string;
+    memberAgentId?: string;
+    depth?: number;
+    ancestry?: readonly SubagentAncestryEntry[];
     parentAgentId?: string;
     phase: SubagentUpdatePhase;
     data?: unknown;
     label?: string;
     timestamp: string;
 }
+export {};

package/dist/types/types/schedules.d.ts

@@ -0,0 +1,306 @@
+import { z } from 'zod';
+/** Cadences the dialog builds from structured pickers (hour, minute, weekday). */
+export declare const scheduleStructuredFrequencies: readonly ["hourly", "daily", "weekdays", "weekly"];
+export type ScheduleStructuredFrequency = (typeof scheduleStructuredFrequencies)[number];
+export declare const scheduleFrequencies: readonly ["hourly", "daily", "weekdays", "weekly", "cron"];
+export type ScheduleFrequency = (typeof scheduleFrequencies)[number];
+/** Bounds a stored expression. Generous for five fields, because each one can hold a
+ *  list: an every-minute-of-the-hour cadence spelled out runs past two hundred chars. */
+export declare const SCHEDULE_CRON_MAX_LENGTH = 256;
+export declare const scheduleTargets: readonly ["new"];
+export type ScheduleTarget = (typeof scheduleTargets)[number];
+export type ScheduleDisabledReason = 'too_many_failures' | 'agent_deleted' | 'invalid_schedule' | 'permission_revoked' | 'insufficient_balance' | 'project_deleted' | 'project_required';
+export type ScheduleRunStatus = 'started' | 'requires_action' | 'success' | 'error' | 'interrupted' | 'skipped_overlap' | 'skipped_balance';
+export declare const structuredCadenceSchema: z.ZodObject<{
+    frequency: z.ZodEnum<["hourly", "daily", "weekdays", "weekly"]>;
+    hour: z.ZodNumber;
+    minute: z.ZodNumber;
+    daysOfWeek: z.ZodOptional<z.ZodEffects<z.ZodArray<z.ZodNumber, "many">, number[], number[]>>;
+}, "strip", z.ZodTypeAny, {
+    frequency: "hourly" | "daily" | "weekdays" | "weekly";
+    hour: number;
+    minute: number;
+    daysOfWeek?: number[] | undefined;
+}, {
+    frequency: "hourly" | "daily" | "weekdays" | "weekly";
+    hour: number;
+    minute: number;
+    daysOfWeek?: number[] | undefined;
+}>;
+export type TStructuredCadence = z.infer<typeof structuredCadenceSchema>;
+/**
+ * A raw cron expression carries its own hour and minute, so it cannot share the
+ * structured shape: there is no single `hour` for `0 9,17 * * 1-5`. Syntax is
+ * validated server-side by croner, the same parser the engine fires from, rather
+ * than by a regex that would accept patterns croner then rejects at fire time.
+ */
+export declare const cronCadenceSchema: z.ZodObject<{
+    frequency: z.ZodLiteral<"cron">;
+    expression: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    frequency: "cron";
+    expression: string;
+}, {
+    frequency: "cron";
+    expression: string;
+}>;
+export type TCronCadence = z.infer<typeof cronCadenceSchema>;
+export declare const scheduleCadenceSchema: z.ZodDiscriminatedUnion<"frequency", [z.ZodObject<{
+    frequency: z.ZodEnum<["hourly", "daily", "weekdays", "weekly"]>;
+    hour: z.ZodNumber;
+    minute: z.ZodNumber;
+    daysOfWeek: z.ZodOptional<z.ZodEffects<z.ZodArray<z.ZodNumber, "many">, number[], number[]>>;
+}, "strip", z.ZodTypeAny, {
+    frequency: "hourly" | "daily" | "weekdays" | "weekly";
+    hour: number;
+    minute: number;
+    daysOfWeek?: number[] | undefined;
+}, {
+    frequency: "hourly" | "daily" | "weekdays" | "weekly";
+    hour: number;
+    minute: number;
+    daysOfWeek?: number[] | undefined;
+}>, z.ZodObject<{
+    frequency: z.ZodLiteral<"cron">;
+    expression: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    frequency: "cron";
+    expression: string;
+}, {
+    frequency: "cron";
+    expression: string;
+}>]>;
+export type TScheduleCadence = z.infer<typeof scheduleCadenceSchema>;
+export declare const isCronCadence: (cadence: TScheduleCadence) => cadence is TCronCadence;
+export declare const createSchedulePayloadSchema: z.ZodObject<{
+    name: z.ZodString;
+    prompt: z.ZodString;
+    agent_id: z.ZodString;
+    cadence: z.ZodDiscriminatedUnion<"frequency", [z.ZodObject<{
+        frequency: z.ZodEnum<["hourly", "daily", "weekdays", "weekly"]>;
+        hour: z.ZodNumber;
+        minute: z.ZodNumber;
+        daysOfWeek: z.ZodOptional<z.ZodEffects<z.ZodArray<z.ZodNumber, "many">, number[], number[]>>;
+    }, "strip", z.ZodTypeAny, {
+        frequency: "hourly" | "daily" | "weekdays" | "weekly";
+        hour: number;
+        minute: number;
+        daysOfWeek?: number[] | undefined;
+    }, {
+        frequency: "hourly" | "daily" | "weekdays" | "weekly";
+        hour: number;
+        minute: number;
+        daysOfWeek?: number[] | undefined;
+    }>, z.ZodObject<{
+        frequency: z.ZodLiteral<"cron">;
+        expression: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        frequency: "cron";
+        expression: string;
+    }, {
+        frequency: "cron";
+        expression: string;
+    }>]>;
+    timezone: z.ZodString;
+    target: z.ZodDefault<z.ZodEnum<["new"]>>;
+    file_ids: z.ZodOptional<z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>>;
+    /**
+     * Chat project each run's conversation is filed under. `null` clears the scope.
+     * Ownership is checked server-side at write time and again at every fire, so a
+     * deleted project disables the schedule instead of silently filing runs loose.
+     */
+    chatProjectId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Client-generated key making creation idempotent across retries. Creation commits
+     * the row and arms it in two writes, so a failure between them leaves the client
+     * unable to tell whether anything persisted; retrying blind can produce two recurring
+     * schedules. A retry carrying the same key resolves to the original row instead.
+     * REQUIRED: an optional key preserves the keyless duplicate path for any client
+     * that omits it, which is exactly the failure the key exists to close.
+     */
+    clientRequestId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    agent_id: string;
+    clientRequestId: string;
+    prompt: string;
+    enabled: boolean;
+    timezone: string;
+    cadence: {
+        frequency: "hourly" | "daily" | "weekdays" | "weekly";
+        hour: number;
+        minute: number;
+        daysOfWeek?: number[] | undefined;
+    } | {
+        frequency: "cron";
+        expression: string;
+    };
+    target: "new";
+    chatProjectId?: string | null | undefined;
+    file_ids?: string[] | undefined;
+}, {
+    name: string;
+    agent_id: string;
+    clientRequestId: string;
+    prompt: string;
+    timezone: string;
+    cadence: {
+        frequency: "hourly" | "daily" | "weekdays" | "weekly";
+        hour: number;
+        minute: number;
+        daysOfWeek?: number[] | undefined;
+    } | {
+        frequency: "cron";
+        expression: string;
+    };
+    chatProjectId?: string | null | undefined;
+    file_ids?: string[] | undefined;
+    enabled?: boolean | undefined;
+    target?: "new" | undefined;
+}>;
+export type TCreateSchedule = z.infer<typeof createSchedulePayloadSchema>;
+/** Idempotency is a property of the CREATE attempt, not of the schedule's config. */
+export declare const updateSchedulePayloadSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    chatProjectId: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+    file_ids: z.ZodOptional<z.ZodOptional<z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>>>;
+    agent_id: z.ZodOptional<z.ZodString>;
+    prompt: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    timezone: z.ZodOptional<z.ZodString>;
+    cadence: z.ZodOptional<z.ZodDiscriminatedUnion<"frequency", [z.ZodObject<{
+        frequency: z.ZodEnum<["hourly", "daily", "weekdays", "weekly"]>;
+        hour: z.ZodNumber;
+        minute: z.ZodNumber;
+        daysOfWeek: z.ZodOptional<z.ZodEffects<z.ZodArray<z.ZodNumber, "many">, number[], number[]>>;
+    }, "strip", z.ZodTypeAny, {
+        frequency: "hourly" | "daily" | "weekdays" | "weekly";
+        hour: number;
+        minute: number;
+        daysOfWeek?: number[] | undefined;
+    }, {
+        frequency: "hourly" | "daily" | "weekdays" | "weekly";
+        hour: number;
+        minute: number;
+        daysOfWeek?: number[] | undefined;
+    }>, z.ZodObject<{
+        frequency: z.ZodLiteral<"cron">;
+        expression: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        frequency: "cron";
+        expression: string;
+    }, {
+        frequency: "cron";
+        expression: string;
+    }>]>>;
+    target: z.ZodOptional<z.ZodDefault<z.ZodEnum<["new"]>>>;
+} & {
+    /**
+     * The configRevision the client's edit was computed from (captured when the
+     * dialog opened). The server fences the update on it, so a concurrent edit
+     * from another tab answers 409 instead of being silently overwritten by a
+     * payload rebuilt from a stale snapshot (cadence is sent whole, so the
+     * server-side fresh-read fence alone cannot detect this).
+     */
+    expectedConfigRevision: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    name?: string | undefined;
+    chatProjectId?: string | null | undefined;
+    file_ids?: string[] | undefined;
+    agent_id?: string | undefined;
+    prompt?: string | undefined;
+    enabled?: boolean | undefined;
+    timezone?: string | undefined;
+    cadence?: {
+        frequency: "hourly" | "daily" | "weekdays" | "weekly";
+        hour: number;
+        minute: number;
+        daysOfWeek?: number[] | undefined;
+    } | {
+        frequency: "cron";
+        expression: string;
+    } | undefined;
+    target?: "new" | undefined;
+    expectedConfigRevision?: number | undefined;
+}, {
+    name?: string | undefined;
+    chatProjectId?: string | null | undefined;
+    file_ids?: string[] | undefined;
+    agent_id?: string | undefined;
+    prompt?: string | undefined;
+    enabled?: boolean | undefined;
+    timezone?: string | undefined;
+    cadence?: {
+        frequency: "hourly" | "daily" | "weekdays" | "weekly";
+        hour: number;
+        minute: number;
+        daysOfWeek?: number[] | undefined;
+    } | {
+        frequency: "cron";
+        expression: string;
+    } | undefined;
+    target?: "new" | undefined;
+    expectedConfigRevision?: number | undefined;
+}>;
+export type TUpdateSchedule = z.infer<typeof updateSchedulePayloadSchema>;
+export type TScheduleLastRun = {
+    conversationId?: string;
+    status: ScheduleRunStatus;
+    error?: string;
+    firedAt: string;
+};
+export type TSchedule = {
+    id: string;
+    user: string;
+    name: string;
+    prompt: string;
+    agent_id: string;
+    cadence: TScheduleCadence;
+    timezone: string;
+    target: ScheduleTarget;
+    file_ids?: string[];
+    chatProjectId?: string | null;
+    enabled: boolean;
+    disabledReason?: ScheduleDisabledReason;
+    nextRunAt?: string;
+    lastRun?: TScheduleLastRun;
+    runCount: number;
+    failureCount: number;
+    configRevision?: number;
+    createdAt: string;
+    updatedAt: string;
+};
+export type TScheduleRun = {
+    scheduleId: string;
+    scheduledFor: string;
+    firedAt?: string;
+    conversationId?: string;
+    status: ScheduleRunStatus;
+    error?: string;
+    droppedFileIds?: string[];
+    durationMs?: number;
+};
+/** Server-resolved policy the dialog must mirror. Sourced from the same
+ *  per-principal `interface.schedules` resolution the write handlers and the fire
+ *  path enforce, so the form can never offer a choice the server would refuse. */
+export type TScheduleLimits = {
+    maxPerUser: number;
+    /** Served with the list so the dialog can refuse a cadence the floor would reject
+     *  rather than surfacing it as a 400 after submit. */
+    minIntervalMinutes: number;
+    /** Every schedule must be filed under a chat project. */
+    requireProject: boolean;
+    /** Operator-pinned destination project; when set it is the ONLY destination and
+     *  the client must not offer a picker. */
+    projectId?: string;
+};
+export type TSchedulesResponse = {
+    schedules: TSchedule[];
+    limits: TScheduleLimits;
+};
+export type TScheduleRunNowResponse = {
+    scheduleId: string;
+    conversationId: string;
+    status: 'started';
+};

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

@@ -33,11 +33,20 @@ export type SkillSource = 'inline' | 'deployment' | 'github' | 'notion';
  * everything else (including root-level files) is `other`.
  */
 export type SkillFileCategory = 'script' | 'reference' | 'asset' | 'other';
+/** Nested object inside a structured frontmatter key. */
+export type SkillFrontmatterObject = {
+    [key: string]: SkillFrontmatterValue | undefined;
+};
 /**
- * Allowed value types inside a skill's YAML frontmatter.
- * Kept strict so callers cannot slip arbitrary `unknown` payloads through the API.
+ * Allowed value types inside a skill's YAML frontmatter. Scalars cover the
+ * documented keys; nested arrays and objects describe the structured ones
+ * (`hooks`, `metadata`, `references`), which real `SKILL.md` files write as a
+ * list, a list of objects, or a map.
+ *
+ * Still no `unknown` or `any`: the payload is JSON-safe by construction, and
+ * the server bounds depth, string length and array size when validating it.
  */
-export type SkillFrontmatterValue = string | number | boolean | string[] | null;
+export type SkillFrontmatterValue = string | number | boolean | null | SkillFrontmatterValue[] | SkillFrontmatterObject;
 /**
  * Structured YAML frontmatter for a skill. All keys are optional on the wire
  * because not every skill document carries a complete frontmatter block —
@@ -95,8 +104,8 @@ export type TSkillWarning = {
  * - `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.
+ *   (those live as top-level columns). Known keys receive value validation;
+ *   unknown keys are retained and reported as non-blocking warnings.
  * - `source`/`sourceMetadata` identify whether the row is user-authored,
  *   deployment-provided, or mirrored from an external source such as GitHub.
  */
@@ -200,11 +209,26 @@ export type TGitHubSkillSyncCredentialSummary = {
     updatedAt?: string;
     createdAt?: string;
 };
+/** One upstream skill a sync run dropped, with the reason it was dropped. */
+export type TGitHubSkillSyncSkippedSkill = {
+    path: string;
+    name?: string;
+    errorCode: string;
+    errorMessage: string;
+};
+/** One upstream file a sync run published a skill without, and why. */
+export type TGitHubSkillSyncSkippedFile = {
+    path: string;
+    skillPath: string;
+    errorCode: string;
+    errorMessage: string;
+};
 export type TGitHubSkillSyncSourceStatus = {
     provider: 'github';
     sourceId: string;
     tenantId?: string;
-    status: 'idle' | 'running' | 'succeeded' | 'failed' | 'skipped';
+    /** `partial`: some skills published, others were skipped (see `skippedSkills`). */
+    status: 'idle' | 'running' | 'succeeded' | 'partial' | 'failed' | 'skipped';
     credentialKey?: string;
     credentialPresent: boolean;
     owner?: string;
@@ -221,6 +245,10 @@ export type TGitHubSkillSyncSourceStatus = {
     syncedFileCount: number;
     deletedSkillCount: number;
     deletedFileCount: number;
+    skippedSkillCount: number;
+    skippedSkills?: TGitHubSkillSyncSkippedSkill[];
+    skippedFileCount: number;
+    skippedFiles?: TGitHubSkillSyncSkippedFile[];
     updatedAt?: string;
     createdAt?: string;
 };