@blade-hq/agent-kit 1.0.24 → 1.0.27

package/dist/react/sockets/event-bridge.d.ts

@@ -0,0 +1,115 @@
+import type { BladeClient } from "../../client/index.js";
+import type { MessageContent } from "../schemas/message.js";
+type WorkspaceFilesChangedEvent = {
+    sessionId: string;
+    filePath?: string;
+};
+type AgentBoardBoardTaskChangedEvent = {
+    [key: string]: any;
+};
+type AgentBoardFileOpEvent = {
+    project_id: number;
+    session_id: string;
+    tool_call_id?: string | null;
+    action: string;
+    file_path: string;
+    description?: string | null;
+    content_preview?: string | null;
+    final_content?: string | null;
+    content_delta?: boolean | null;
+    is_final?: boolean | null;
+    created_at: string;
+};
+export declare function setOnWorkspaceFilesChanged(fn: ((event: WorkspaceFilesChangedEvent) => void) | null): void;
+export declare class AgentSocket {
+    private client;
+    private socket;
+    private subscribedSession;
+    private readonly attachedSessions;
+    private readonly previewArtifactsByToolCall;
+    private readonly deliveredBridgeKeys;
+    private readonly pendingReplayMessages;
+    private readonly pendingReplayModes;
+    private readonly oomNotifiedKeys;
+    private readonly pendingTurnPatches;
+    private readonly joinedSessions;
+    private readonly requestedJoins;
+    private readonly pendingJoins;
+    private readonly recentChatEndAt;
+    private readonly boardProjectRefCounts;
+    private frontendTelemetryCounter;
+    private patchFlushHandle;
+    private patchFlushCancel;
+    private readonly projectionBuilder;
+    constructor(client: BladeClient);
+    private _ensureConnected;
+    private _resolveSessionId;
+    private _reportFrontendTelemetry;
+    private _queueTurnPatch;
+    private _scheduleTurnPatchFlush;
+    private _flushPendingTurnPatches;
+    private _bindStoreHandlers;
+    private _bindConnectionHandlers;
+    private _applyProjectionSideEffects;
+    private _notifySandboxOom;
+    private _syncSessionTurnsFromHistory;
+    private _applySystemNotification;
+    subscribe(sessionId: string): void;
+    subscribeAgentBoardProject(projectId: string | number): void;
+    unsubscribeAgentBoardProject(projectId: string | number): void;
+    onAgentBoardTaskChanged(handler: (data: AgentBoardBoardTaskChangedEvent) => void): () => void;
+    onAgentBoardFileOp(handler: (data: AgentBoardFileOpEvent) => void): () => void;
+    /**
+     * 订阅 session:updated（智能体意图、状态等会话属性变更）。全局 handler 只会
+     * patch 已在 useSessionStore 列表里的会话；看板任务这类不在列表里的
+     * 会话，由调用方通过本方法自行消费属性更新。
+     */
+    onSessionUpdated(handler: (data: {
+        session_id?: string;
+        intent?: string;
+        status?: string;
+    }) => void): () => void;
+    unsubscribe(): void;
+    /**
+     * 附加订阅：仅把当前 sid 加进 sessionId 的 room，不切 subscribedSession，
+     * 也不清空当前会话的 artifact/card state。用于"并行拟制"这类场景 ——
+     * 创建 N 个后台 session 后需要收到它们的 chat:end / task:updated 才能让
+     * 成果表里那几条卡片状态流转到"已完成"；缺失订阅时广播事件永远到不了
+     * 前端，卡片就会停留在乐观写入的"运行中"态。
+     *
+     * 幂等：后端 session:subscribe handler 只做 enter_room，重复 emit 无副作用。
+     * 同时把 sessionId 记到 attachedSessions，连接断开重连时一并重新订阅，
+     * 避免长会话期间断网后再回来时丢掉该 session 的 turn 事件。
+     */
+    attachSession(sessionId: string): void;
+    private _ensureJoined;
+    private _refreshRunningState;
+    private _shouldWaitForJoinBeforeSend;
+    send(sessionId: string, message: MessageContent, mode?: string, askuserAnswer?: Record<string, unknown>, extras?: {
+        model?: string;
+        thinkingOverride?: boolean;
+        whatif?: {
+            from_step: number;
+            quotes: Array<Record<string, unknown>>;
+            deprecate_entry_ids: string[];
+        };
+        replay_decision?: "keep_replay" | "continue_replay";
+    }): Promise<void>;
+    private _ensureSessionIdleBeforeSend;
+    /**
+     * 在 agent loop 运行期间追加补充消息。
+     * 消息会在下一轮 LLM 调用前以 user-supplement 形式注入。
+     */
+    append(sessionId: string, message: string): void;
+    stop(sessionId: string): Promise<Record<string, unknown>>;
+    compact(sessionId: string): Promise<Record<string, unknown>>;
+    reconnect(): void;
+    disconnect(): void;
+    destroy(): void;
+    on(event: string, listener: (...args: any[]) => void): this;
+    off(event: string, listener: (...args: any[]) => void): this;
+    emit(event: string, data?: any): this;
+    getSubscribedSession(): string | null;
+}
+export declare function bridgeSocketEvents(client: BladeClient, _stores?: unknown): AgentSocket;
+export {};

package/dist/react/sockets/socket-state.d.ts

@@ -0,0 +1,4 @@
+import type { AgentSocket } from "./event-bridge.js";
+export declare let agentSocket: AgentSocket | null;
+export declare function setAgentSocket(nextSocket: AgentSocket | null): void;
+export declare function getSocket(): AgentSocket;

package/dist/react/stores/answer-callback-store.d.ts

@@ -0,0 +1,9 @@
+import type { AskUserAnswerData } from "../components/chat/AskUserQuestionBlock.js";
+import { type ClientAwareState } from "./client-aware.js";
+export type AnswerCallback = (answer: string, toolCallId: string, answerData: AskUserAnswerData) => void;
+interface AnswerCallbackState extends ClientAwareState {
+    callbacks: Record<string, AnswerCallback | undefined>;
+    setAnswerCallback: (sessionId: string, callback?: AnswerCallback) => void;
+}
+export declare const useAnswerCallbackStore: import("zustand").UseBoundStore<import("zustand").StoreApi<AnswerCallbackState>>;
+export {};

package/dist/react/stores/auth-store.d.ts

@@ -0,0 +1,38 @@
+import { type ClientAwareState } from "./client-aware.js";
+interface User {
+    id: string;
+    username: string;
+    display_name?: string | null;
+    avatar_url: string | null;
+    is_admin?: boolean;
+}
+interface AuthState extends ClientAwareState {
+    token: string | null;
+    socketAuthToken: string | null;
+    user: User | null;
+    loading: boolean;
+    error: string | null;
+    logout: () => void;
+    checkAuth: () => Promise<void>;
+    hydrateFromCookie: () => Promise<void>;
+}
+export declare const useAuthStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<AuthState>, "persist" | "setState"> & {
+    setState(partial: AuthState | Partial<AuthState> | ((state: AuthState) => AuthState | Partial<AuthState>), replace?: false | undefined): unknown;
+    setState(state: AuthState | ((state: AuthState) => AuthState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<AuthState, {
+            token: string | null;
+            user: User | null;
+        }, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: AuthState) => void) => () => void;
+        onFinishHydration: (fn: (state: AuthState) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<AuthState, {
+            token: string | null;
+            user: User | null;
+        }, unknown>>;
+    };
+}>;
+export {};

package/dist/react/stores/background-store.d.ts

@@ -0,0 +1,13 @@
+import type { BackgroundTask } from "../schemas/background.js";
+import { type ClientAwareState } from "./client-aware.js";
+interface BackgroundState extends ClientAwareState {
+    tasks: Record<string, BackgroundTask[]>;
+    selectedTaskId: Record<string, string | null>;
+    dismissedTaskIds: Record<string, string[]>;
+    setTasks: (sessionId: string, tasks: BackgroundTask[]) => void;
+    upsertTask: (sessionId: string, task: BackgroundTask) => void;
+    selectTask: (sessionId: string, taskId: string | null) => void;
+    dismissTask: (sessionId: string, taskId: string) => void;
+}
+export declare const useBackgroundStore: import("zustand").UseBoundStore<import("zustand").StoreApi<BackgroundState>>;
+export {};

package/dist/react/stores/card-state-store.d.ts

@@ -0,0 +1,10 @@
+import { type ClientAwareState } from "./client-aware.js";
+interface CardStateStore extends ClientAwareState {
+    states: Record<string, unknown>;
+    getCardState: <T>(cardId: string) => T | undefined;
+    setCardState: <T>(cardId: string, state: T) => void;
+    removeCardState: (cardId: string) => void;
+    clearAllStates: () => void;
+}
+export declare const useCardStateStore: import("zustand").UseBoundStore<import("zustand").StoreApi<CardStateStore>>;
+export {};

package/dist/react/stores/chat-store.d.ts

@@ -0,0 +1,34 @@
+import type { AskUserAnswerData } from "../components/chat/AskUserQuestionBlock.js";
+import type { ChatMessage, CompactionInfo, MessageContent } from "../schemas/message.js";
+import type { PatchEnvelope, TurnProjection } from "../schemas/projection.js";
+import { type ClientAwareState } from "./client-aware.js";
+export declare function setChatStoreSessionAccessor(fn: () => string | null): void;
+export interface AgentLoopInfo {
+    toolCallId: string;
+    description: string;
+    status: "running" | "done" | "error" | "cancelled" | "awaiting_answer";
+}
+export interface ActiveCompactionState extends CompactionInfo {
+    turn_id: string;
+    status: "streaming" | "completed" | "paused" | "failed" | "interrupted";
+}
+interface ChatState extends ClientAwareState {
+    turns: Record<string, TurnProjection[]>;
+    messages: Record<string, ChatMessage[]>;
+    askAnswers: Record<string, Record<string, AskUserAnswerData>>;
+    isStreaming: Record<string, boolean>;
+    agentLoops: Record<string, Record<string, AgentLoopInfo>>;
+    activeCompactions: Record<string, ActiveCompactionState | null>;
+    addUserMessage: (sessionId: string, content: MessageContent) => void;
+    setTurns: (sessionId: string, turns: TurnProjection[]) => void;
+    upsertTurn: (sessionId: string, turn: TurnProjection) => void;
+    applyTurnPatch: (sessionId: string, patch: PatchEnvelope) => void;
+    addErrorMessage: (sessionId: string, content: string) => void;
+    markInterrupted: (sessionId: string) => void;
+    markFailed: (sessionId: string) => void;
+    setStreaming: (sessionId: string, streaming: boolean) => void;
+    setAskAnswers: (sessionId: string, answers: Record<string, AskUserAnswerData>) => void;
+    clearMessages: (sessionId: string) => void;
+}
+export declare const useChatStore: import("zustand").UseBoundStore<import("zustand").StoreApi<ChatState>>;
+export {};

package/dist/react/stores/client-aware.d.ts

@@ -0,0 +1,7 @@
+import type { StoreApi } from "zustand";
+import type { BladeClient } from "../../client/index.js";
+export interface ClientAwareState {
+    _client: BladeClient | null;
+    setClient: (client: BladeClient) => void;
+}
+export declare function createClientActions<T extends ClientAwareState>(set: StoreApi<T>["setState"]): ClientAwareState;

package/dist/react/stores/connection-store.d.ts

@@ -0,0 +1,14 @@
+import { type ClientAwareState } from "./client-aware.js";
+export type ConnectionStatus = "connecting" | "connected" | "disconnected";
+export interface ConnectionState extends ClientAwareState {
+    status: ConnectionStatus;
+    reconnectAttempt: number;
+    lastConnectedAt: number | null;
+    lastDisconnectedAt: number | null;
+    hasEverConnected: boolean;
+    markConnecting: (attempt?: number) => void;
+    markConnected: () => void;
+    markDisconnected: () => void;
+    reset: () => void;
+}
+export declare const useConnectionStore: import("zustand").UseBoundStore<import("zustand").StoreApi<ConnectionState>>;

package/dist/react/stores/gis-store.d.ts

@@ -0,0 +1,19 @@
+import type { GisGoal, GisMapCommand, GisResource, GisTarget } from "../schemas/gis.js";
+import { type ClientAwareState } from "./client-aware.js";
+interface GisStateStore extends ClientAwareState {
+    goalsBySession: Record<string, GisGoal[]>;
+    resourcesBySession: Record<string, GisResource[]>;
+    targetsBySession: Record<string, GisTarget[]>;
+    pendingMapCommandsBySession: Record<string, GisMapCommand[]>;
+    setGoals: (sessionId: string, goals: GisGoal[]) => void;
+    setResources: (sessionId: string, resources: GisResource[]) => void;
+    setTargets: (sessionId: string, targets: GisTarget[]) => void;
+    pushMapCommand: (sessionId: string, command: Omit<GisMapCommand, "id" | "createdAt">) => void;
+    consumeMapCommand: (sessionId: string, commandId: string) => void;
+    getGoals: (sessionId: string) => GisGoal[];
+    getResources: (sessionId: string) => GisResource[];
+    getTargets: (sessionId: string) => GisTarget[];
+    getPendingMapCommands: (sessionId: string) => GisMapCommand[];
+}
+export declare const useGisStore: import("zustand").UseBoundStore<import("zustand").StoreApi<GisStateStore>>;
+export {};

package/dist/react/stores/index.d.ts

@@ -0,0 +1,14 @@
+export { attachClientToStores } from "../bootstrap.js";
+export * from "./answer-callback-store.js";
+export * from "./auth-store.js";
+export * from "./background-store.js";
+export * from "./card-state-store.js";
+export * from "./chat-store.js";
+export * from "./connection-store.js";
+export * from "./gis-store.js";
+export * from "./runtime-features-store.js";
+export * from "./runtime-store.js";
+export * from "./session-store.js";
+export * from "./task-store.js";
+export * from "./ui-bridge-store.js";
+export * from "./ui-store.js";

package/dist/react/stores/runtime-features-store.d.ts

@@ -0,0 +1,21 @@
+import { type ClientAwareState } from "./client-aware.js";
+export type AsrProvider = "volcengine" | "qwen";
+interface RuntimeFeaturesState extends ClientAwareState {
+    asrEnabled: boolean;
+    asrProvider: AsrProvider;
+    publicSharingEnabled: boolean;
+    memoryEnabled: boolean;
+    checkpointsEnabled: boolean;
+    setFeatures: (features: {
+        asrEnabled?: boolean;
+        asrProvider?: AsrProvider;
+        publicSharingEnabled?: boolean;
+        memoryEnabled?: boolean;
+        checkpointsEnabled?: boolean;
+    }) => void;
+}
+/**
+ * 运行期特性开关（由后端 /api/config 下发）。默认全部关闭，main.tsx 启动时 fetch 一次填充。
+ */
+export declare const useRuntimeFeaturesStore: import("zustand").UseBoundStore<import("zustand").StoreApi<RuntimeFeaturesState>>;
+export {};

package/dist/react/stores/runtime-store.d.ts

@@ -0,0 +1,18 @@
+import { type ClientAwareState } from "./client-aware.js";
+export interface RuntimeEvent {
+    id: string;
+    sessionId: string;
+    type: string;
+    title: string;
+    status: "info" | "running" | "done" | "error";
+    timestamp: string;
+    loopName?: string;
+    detail?: string;
+}
+interface RuntimeState extends ClientAwareState {
+    events: Record<string, RuntimeEvent[]>;
+    addEvent: (sessionId: string, event: Omit<RuntimeEvent, "id" | "sessionId" | "timestamp">) => void;
+    clearSession: (sessionId: string) => void;
+}
+export declare const useRuntimeStore: import("zustand").UseBoundStore<import("zustand").StoreApi<RuntimeState>>;
+export {};

package/dist/react/stores/session-store.d.ts

@@ -0,0 +1,44 @@
+import type { ModeId, SessionInfo, SessionStatus } from "../schemas/session.js";
+import { type ClientAwareState } from "./client-aware.js";
+export type SessionMode = ModeId;
+interface SessionState extends ClientAwareState {
+    sessions: SessionInfo[];
+    activeSessionId: string | null;
+    loading: boolean;
+    modes: Record<string, SessionMode>;
+    rewindDrafts: Record<string, string>;
+    errorMessages: Record<string, string>;
+    /** Session IDs that were just created and haven't had their first history load yet */
+    _freshSessions: Set<string>;
+    fetchAllSessions: () => Promise<void>;
+    createSession: (intent?: string) => Promise<string>;
+    registerCreatedSession: (session: SessionInfo, mode?: SessionMode, options?: {
+        fresh?: boolean;
+    }) => void;
+    upsertSession: (session: SessionInfo) => void;
+    isFreshSession: (sessionId: string) => boolean;
+    setActiveSession: (id: string) => void;
+    clearActiveSession: () => void;
+    deleteSession: (id: string) => Promise<void>;
+    updateSessionStatus: (sessionId: string, status: SessionStatus) => void;
+    updateSessionIntent: (sessionId: string, intent: string) => void;
+    /**
+     * ship-attack v2：通用增量更新 session 字段。用于 session:updated 等事件
+     * 广播"后端刚改了 session 元数据（intent / bound_skill_id / ...）"时，
+     * 前端原地 patch sessions 缓存，而不需要重新拉整个列表。
+     */
+    patchSession: (sessionId: string, patch: Partial<SessionInfo>) => void;
+    pinSession: (sessionId: string, pinned: boolean) => Promise<void>;
+    setErrorMessage: (sessionId: string, message: string) => void;
+    clearErrorMessage: (sessionId: string) => void;
+    setRewindDraft: (sessionId: string, text: string | null) => void;
+    setMode: (sessionId: string, mode: SessionMode) => void;
+    togglePlanningMode: (sessionId: string) => void;
+    toggleSharing: (sessionId: string) => Promise<void>;
+    reset: () => void;
+}
+export declare function setOnSessionChange(fn: (sessionId: string | null) => void): void;
+/** 侧栏等使用 React Query 拉取会话列表时，与 zustand patch 同步失效。 */
+export declare function invalidateHomeSidebarSessions(): void;
+export declare const useSessionStore: import("zustand").UseBoundStore<import("zustand").StoreApi<SessionState>>;
+export {};

package/dist/react/stores/task-store.d.ts

@@ -0,0 +1,9 @@
+import type { Task } from "../schemas/task.js";
+import { type ClientAwareState } from "./client-aware.js";
+interface TaskState extends ClientAwareState {
+    tasks: Record<string, Task[]>;
+    setTasks: (sessionId: string, tasks: Task[]) => void;
+    getTasks: (sessionId: string) => Task[];
+}
+export declare const useTaskStore: import("zustand").UseBoundStore<import("zustand").StoreApi<TaskState>>;
+export {};

package/dist/react/stores/ui-bridge-store.d.ts

@@ -0,0 +1,32 @@
+import { type ClientAwareState } from "./client-aware.js";
+export interface PendingContextSignal {
+    id: string;
+    label: string;
+    content: string;
+    imageUrl?: string;
+}
+export interface DraftAppendSignal {
+    id: string;
+    text: string;
+}
+export interface SendRequestSignal {
+    id: string;
+}
+interface UiBridgeState extends ClientAwareState {
+    pendingContexts: Record<string, PendingContextSignal[]>;
+    draftAppends: Record<string, DraftAppendSignal[]>;
+    sendRequests: Record<string, SendRequestSignal[]>;
+    addPendingContext: (sessionId: string, context: Omit<PendingContextSignal, "id">) => void;
+    removePendingContext: (sessionId: string, contextId: string) => void;
+    consumePendingContexts: (sessionId: string) => PendingContextSignal[];
+    clearPendingContexts: (sessionId: string) => void;
+    addDraftAppend: (sessionId: string, text: string) => void;
+    consumeDraftAppends: (sessionId: string) => DraftAppendSignal[];
+    clearDraftAppends: (sessionId: string) => void;
+    addSendRequest: (sessionId: string) => void;
+    consumeSendRequests: (sessionId: string) => SendRequestSignal[];
+    clearSendRequests: (sessionId: string) => void;
+    clearSession: (sessionId: string) => void;
+}
+export declare const useUiBridgeStore: import("zustand").UseBoundStore<import("zustand").StoreApi<UiBridgeState>>;
+export {};

package/dist/react/stores/ui-store.d.ts

@@ -0,0 +1,69 @@
+import { type ClientAwareState } from "./client-aware.js";
+type ThemeValue = "light" | "dark" | "system";
+export declare function resolveEffectiveTheme(theme: ThemeValue): "light" | "dark";
+export interface PreviewTarget {
+    type: "file" | "markdown" | "image" | "url" | "html" | "resource-html" | "resource-uri" | "diff" | "pdf" | "docx" | "video" | "audio" | "download" | "card" | "excel" | "csv" | "ppt";
+    content: string;
+    title?: string;
+    /** Stable identity key for tab deduplication (e.g. file_path). Falls back to title. */
+    key?: string;
+    /** For diff type: the old content before edit */
+    oldContent?: string;
+    /** Optional bridge session binding for resource iframes. */
+    bridgeSessionId?: string;
+    /** Original source file URL when preview content uses a derived representation (e.g. PPT -> PDF). */
+    sourceUrl?: string;
+    /** Changes when an artifact with the same key is updated in place. */
+    revision?: number;
+}
+export type ActiveRightTab = "situation" | "preview" | "skill-test" | "vibe-service" | "vibe-preview" | "vibe-access" | "solution-editor" | "vibe-board";
+interface UpsertArtifactOptions {
+    reveal?: boolean;
+    activate?: boolean;
+}
+interface UiState extends ClientAwareState {
+    leftPanelSize: number;
+    rightPanelSize: number;
+    leftPanelCollapsed: boolean;
+    rightPanelCollapsed: boolean;
+    activeRightTab: ActiveRightTab;
+    rightTabActivationId: number;
+    rightPanelAutoJump: boolean;
+    rightPanelUnreadTabs: string[];
+    /** All open artifact tabs */
+    artifacts: PreviewTarget[];
+    /** Index of the active tab (-1 if none) */
+    activeArtifactIndex: number;
+    previewUnreadArtifactKeys: string[];
+    theme: ThemeValue;
+    setLeftPanelSize: (size: number) => void;
+    setRightPanelSize: (size: number) => void;
+    setLeftPanelCollapsed: (collapsed: boolean) => void;
+    setRightPanelCollapsed: (collapsed: boolean) => void;
+    toggleLeftPanel: () => void;
+    toggleRightPanel: () => void;
+    setActiveRightTab: (tab: ActiveRightTab) => void;
+    setRightPanelAutoJump: (enabled: boolean) => void;
+    markRightPanelTabUnread: (tab: string) => void;
+    clearRightPanelTabUnread: (tab: string) => void;
+    markPreviewArtifactUnread: (key: string) => void;
+    clearPreviewArtifactUnread: (key: string) => void;
+    activateLatestUnreadArtifact: () => void;
+    /** Add or update an artifact tab (matched by key/title). Opens the panel automatically. */
+    pushArtifact: (target: PreviewTarget) => void;
+    /** Add or update an artifact tab with optional reveal/activate control. */
+    upsertArtifact: (target: PreviewTarget, options?: UpsertArtifactOptions) => void;
+    /** Switch to a tab by index */
+    setActiveArtifact: (index: number) => void;
+    /** Close a tab by index */
+    closeArtifact: (index: number) => void;
+    /** Close a tab by stable key if it exists. */
+    removeArtifactByKey: (key: string) => void;
+    /** Close all tabs and collapse panel */
+    clearArtifacts: () => void;
+    /** Legacy single-target setter for backwards compat */
+    setPreviewTarget: (target: PreviewTarget | null) => void;
+    setTheme: (theme: ThemeValue) => void;
+}
+export declare const useUiStore: import("zustand").UseBoundStore<import("zustand").StoreApi<UiState>>;
+export {};

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

@@ -0,0 +1,7 @@
+export type { ModeId, SessionInfo, SessionStatus, SkillEditorTemplateId, TemplateId } from "../schemas/session.js";
+export type { Task, TaskStatus } from "../schemas/task.js";
+export type { ChatMessage, FileContentPart, ToolCallInfo, MessageContent, MessageContentPart, TextContentPart, ImageUrlContentPart, } from "../schemas/message.js";
+export type { ContentBlock, PatchEnvelope, ToolCallProjection, TurnProjection, } from "../schemas/projection.js";
+export type { ContentDelta, ToolCallCreated, ToolResultDelta, ToolResultDone, LlmResponseDone, ChatEnd, SystemError, SessionStatusEvent, } from "../schemas/event.js";
+export type { BackgroundTask } from "../schemas/background.js";
+export type { SkillSummary, SkillDetail } from "../schemas/skill.js";

package/dist/react/types/solution.d.ts

@@ -0,0 +1,101 @@
+export declare enum LayoutType {
+    Default = "default",
+    SkillEditor = "skill-editor",
+    BladeCoa = "blade-coa",
+    SolutionEditor = "solution-editor",
+    SolutionEditor2 = "solution-editor2",
+    ChatPreview = "chat-preview",
+    ChatOnly = "chat-only",
+    SolutionApp = "solution-app",
+    Custom = "custom"
+}
+export interface Solution {
+    id: string;
+    name: string;
+    version: string;
+    description?: string | null;
+    source?: "builtin" | "personal" | string | null;
+    layout_type: LayoutType | string;
+    initial_mode?: "planning" | "executing" | string | null;
+    initial_message?: string | null;
+    preview?: {
+        url: string;
+        title?: string | null;
+    } | null;
+    layout?: {
+        available?: boolean;
+        source_dir?: string;
+        entry?: string;
+        export?: string;
+    } | null;
+    roles?: BizRole[] | null;
+    data?: Record<string, unknown> | null;
+    ui_config?: SolutionAppUiConfig | null;
+}
+export interface SolutionAppUiConfig {
+    branding: {
+        name: string;
+        subtitle?: string;
+        icon_text: string;
+        icon_gradient?: string;
+    };
+    list: {
+        title: string;
+        create_button: string;
+        card?: {
+            subtitle?: string;
+            stats?: Array<{
+                label: string;
+                value: string;
+                color?: string;
+            }>;
+        };
+    };
+    create: {
+        title: string;
+        description?: string;
+        submit_button: string;
+        sections: Array<{
+            id: string;
+            title: string;
+            description?: string;
+            fields: Array<SolutionAppField>;
+        }>;
+    };
+}
+export type SolutionAppField = {
+    id: string;
+    kind: "textarea";
+    label: string;
+    placeholder?: string;
+} | {
+    id: string;
+    kind: "file-upload";
+    accept?: string[];
+    categories?: Array<{
+        label: string;
+        description: string;
+        color: string;
+    }>;
+};
+export interface SolutionAppState {
+    pipeline: Array<{
+        id: string;
+        label: string;
+        status: "done" | "active" | "pending" | "error";
+    }>;
+    meta: Record<string, {
+        label: string;
+        value: string;
+        color?: string;
+    }>;
+}
+export interface BizRole {
+    id: string;
+    name: string;
+    description?: string | null;
+    preview?: {
+        url: string;
+        title?: string | null;
+    } | null;
+}