@blade-hq/agent-kit 1.0.25 → 1.0.28

package/dist/client/resources/sessions.d.ts

@@ -0,0 +1,253 @@
+import type { BackgroundTask } from "../../react/schemas/background.js";
+import type { TurnProjection } from "../../react/schemas/projection.js";
+import type { SessionDetail, SessionInfo, TemplateId } from "../../react/schemas/session.js";
+import type { Task } from "../../react/schemas/task.js";
+import type { BladeClient, UploadProgress } from "../blade-client.js";
+import type { SessionProfile } from "../types/sdk-profile.js";
+export interface CreateSessionRequest {
+    intent?: string;
+    template_id?: TemplateId;
+    solution_id?: string;
+    biz_role_id?: string | null;
+    primary_skill_id?: string | null;
+    model?: string | null;
+    enable_thinking?: boolean | null;
+    memory_enabled?: boolean | null;
+    env?: Record<string, string>;
+    disable_tools?: string[] | null;
+    session_solution_asset_id?: string | null;
+    compaction_ratio?: number | null;
+}
+export interface CheckpointNode {
+    id: string;
+    parent_id: string | null;
+    content_preview: string;
+    content: string;
+    timestamp: string;
+}
+export type ContentPart = {
+    type: "text";
+    text: string;
+} | {
+    type: "image_url";
+    image_url: {
+        url: string;
+        detail?: string;
+    };
+};
+export interface HistoryNode {
+    id: string;
+    parent_id: string | null;
+    kind: string;
+    role: string;
+    timestamp: string;
+    preview: string;
+    content: string | ContentPart[];
+    tool_calls: Array<{
+        id?: string;
+        type?: string;
+        function?: {
+            name?: string;
+            arguments?: string;
+        };
+    }> | null;
+    usage: {
+        prompt_tokens?: number;
+        completion_tokens?: number;
+        total_tokens?: number;
+    } | null;
+    total_tokens: number;
+    token_diff: number;
+    is_deprecated: boolean;
+    loop_name: string;
+}
+export interface SessionHistory {
+    nodes: HistoryNode[];
+    active_branch: string | null;
+    branches: string[];
+    system_prompt_tokens?: number | null;
+    tools_tokens?: number | null;
+    tokenizer_model?: string | null;
+}
+export interface TokenizeResult {
+    model: string;
+    prompt_tokens: number;
+    prompt: string;
+}
+export interface PaginatedSessionsResult {
+    items: SessionInfo[];
+    total: number;
+    limit: number;
+    offset: number;
+    content_match_truncated?: boolean;
+}
+export interface SkillDevSession {
+    session: SessionInfo;
+    skill_id: string;
+    display_name: string;
+    skill_description: string;
+}
+export interface ShareLinkResult {
+    token: string;
+    url: string;
+    expires_at: string | null;
+}
+export interface SessionContextStats {
+    tokens_used: number;
+    context_window: number;
+    compaction_ratio: number;
+}
+export interface FileEntry {
+    name: string;
+    path: string;
+    is_dir: boolean;
+    created_at: number;
+    tags?: string[];
+}
+export type UploadFileEntry = File | {
+    file: File;
+    name: string;
+};
+export interface UploadFilesOptions {
+    onProgress?: (progress: UploadProgress) => void;
+}
+export interface ImportPreviewSkill {
+    name: string;
+    description: string;
+    path: string;
+}
+export interface ImportPreviewScenario {
+    scenario?: {
+        name?: string;
+    };
+    skills?: string[];
+    preview_urls?: string[];
+    init_script?: string;
+    generated_at?: string;
+}
+export interface ImportPreview {
+    user_messages: string[];
+    turn_count: number;
+    skills: ImportPreviewSkill[];
+    scenario: ImportPreviewScenario | null;
+}
+export declare class SessionsResource {
+    private client;
+    constructor(client: BladeClient);
+    private fetchSessionsPage;
+    listSessions(template_id_prefix?: string, solution_id?: string): Promise<SessionInfo[]>;
+    listSessionsPaginated(params: {
+        limit: number;
+        offset: number;
+        template_id_prefix?: string;
+        solution_id?: string;
+        q?: string;
+    }): Promise<PaginatedSessionsResult>;
+    listSessionsWithSkillData(): Promise<SkillDevSession[]>;
+    createSession(intent?: string, template_id?: TemplateId, primary_skill_id?: string | null): Promise<{
+        session_id: string;
+    }>;
+    createSessionWithRequest(request: CreateSessionRequest): Promise<{
+        session_id: string;
+    }>;
+    createWithProfile(params: {
+        intent: string;
+        profile: SessionProfile;
+    }): Promise<{
+        session_id: string;
+    }>;
+    getSession(sessionId: string, init?: RequestInit): Promise<SessionDetail>;
+    updateSession(sessionId: string, payload: {
+        intent?: string;
+    }): Promise<SessionDetail>;
+    setSessionEnv(sessionId: string, env: Record<string, string>): Promise<SessionDetail>;
+    pinSession(sessionId: string, pinned: boolean): Promise<SessionInfo>;
+    startReplaySession(sourceSessionId: string, speed?: 1 | 2 | 5): Promise<{
+        session_id: string;
+    }>;
+    updateReplaySession(sessionId: string, payload: {
+        speed?: 1 | 2 | 5;
+        status?: "autonomous";
+    }): Promise<{
+        replay_state: SessionInfo["replay_state"];
+    }>;
+    updateSharing(sessionId: string, shared: boolean): Promise<{
+        shared: boolean;
+    }>;
+    updateSessionMemory(sessionId: string, memoryEnabled: boolean): Promise<{
+        memory_enabled: boolean;
+    }>;
+    createShare(sessionId: string): Promise<ShareLinkResult>;
+    revokeShare(sessionId: string, token: string): Promise<{
+        revoked: boolean;
+    }>;
+    getSharedSession(token: string): Promise<TurnProjection[]>;
+    getSessionTasks(sessionId: string): Promise<Task[]>;
+    getSessionTurns(sessionId: string): Promise<TurnProjection[]>;
+    getSessionContextStats(sessionId: string, init?: RequestInit): Promise<SessionContextStats>;
+    getSessionHistory(sessionId: string, init?: RequestInit): Promise<SessionHistory>;
+    tokenizePrompt(prompt: string, model?: string): Promise<TokenizeResult>;
+    tokenizeMessages(messages: Array<Record<string, unknown>>, options?: {
+        model?: string;
+        add_generation_prompt?: boolean;
+        enable_thinking?: boolean | null;
+        tools?: Array<Record<string, unknown>>;
+    }): Promise<TokenizeResult>;
+    getSessionCheckpoints(sessionId: string, init?: RequestInit): Promise<{
+        nodes: CheckpointNode[];
+        leaf_id: string | null;
+    }>;
+    checkoutSession(sessionId: string, checkpointId: string, position: "before" | "turn_end", mode?: "both" | "conversation" | "code", linear?: boolean): Promise<{
+        id: string;
+        content: string;
+        position: string;
+        mode?: string;
+        files_restored?: boolean;
+        linear?: boolean;
+    }>;
+    rewindSession(sessionId: string, checkpointId: string): Promise<{
+        id: string;
+        content: string;
+    }>;
+    switchBranch(sessionId: string, checkpointId: string): Promise<{
+        id: string;
+        leaf_id: string;
+    }>;
+    deleteSession(sessionId: string): Promise<{
+        deleted: boolean;
+    }>;
+    listBackgroundTasks(sessionId: string, init?: RequestInit): Promise<BackgroundTask[]>;
+    getBackgroundTask(sessionId: string, taskId: string, tail?: number, init?: RequestInit): Promise<BackgroundTask>;
+    stopBackgroundTask(sessionId: string, taskId: string): Promise<{
+        message: string;
+        task?: BackgroundTask | null;
+    }>;
+    probeSessionUrl(sessionId: string, url: string): Promise<{
+        reachable: boolean;
+    }>;
+    listDir(sessionId: string, dirPath: string): Promise<FileEntry[]>;
+    uploadFiles(sessionId: string, dirPath: string, files: FileList | File[] | UploadFileEntry[], options?: UploadFilesOptions): Promise<{
+        uploaded: string[];
+        failed: string[];
+    }>;
+    deleteFile(sessionId: string, filePath: string): Promise<void>;
+    writeFile(sessionId: string, filePath: string, content: string): Promise<{
+        success: boolean;
+    }>;
+    renameFile(sessionId: string, filePath: string, newName: string): Promise<{
+        path: string;
+    }>;
+    copyFile(sessionId: string, filePath: string): Promise<{
+        path: string;
+    }>;
+    shareFile(sessionId: string, sourcePath: string, linkName?: string, shareFolder?: string): Promise<{
+        path: string;
+        target: string;
+    }>;
+    getDownloadDirUrl(sessionId: string, dirPath: string): string;
+    exportSession(sessionId: string): Promise<void>;
+    previewImport(file: File): Promise<ImportPreview>;
+    importSession(file: File, name?: string, solutionId?: string | null): Promise<{
+        session_id: string;
+    }>;
+}

package/dist/client/resources/skills.d.ts

@@ -0,0 +1,38 @@
+import type { PartnerSkillInstallPayload, PartnerSkillInstallResult, SessionSkillUploadPayload, SessionSkillUploadResult } from "../../react/schemas/partner-skill.js";
+import type { SkillDetail, SkillSearchResult, SkillStats, SkillSummary } from "../../react/schemas/skill.js";
+import type { BladeClient } from "../blade-client.js";
+export interface GlobalSkillStats {
+    remote_configured: boolean;
+    remote_connected: boolean;
+    installed_skill_count: number;
+}
+export interface InstalledRegistrySkill {
+    id: string;
+    name: string;
+    display_name?: string | null;
+    description?: string | null;
+    is_installed?: boolean;
+    is_preset?: boolean;
+    preinstalled?: boolean;
+    org_display_name?: string | null;
+    has_tools?: boolean;
+}
+export declare class SkillsResource {
+    private client;
+    constructor(client: BladeClient);
+    listSkills(init?: RequestInit): Promise<SkillSummary[]>;
+    listInstalledRegistrySkills(init?: RequestInit): Promise<InstalledRegistrySkill[]>;
+    listSessionSkills(sessionId: string, init?: RequestInit): Promise<SkillSummary[]>;
+    resyncSkills(sessionId: string, init?: RequestInit): Promise<{
+        detail?: string;
+        copied: number;
+        removed: number;
+        preserved: number;
+    }>;
+    searchSkills(query: string, limit?: number, init?: RequestInit): Promise<SkillSearchResult[]>;
+    getSkillStats(sessionId: string, init?: RequestInit): Promise<SkillStats>;
+    getGlobalSkillStats(init?: RequestInit): Promise<GlobalSkillStats>;
+    getSkill(skillName: string, init?: RequestInit): Promise<SkillDetail>;
+    uploadSessionSkill(sessionId: string, payload: SessionSkillUploadPayload, init?: RequestInit): Promise<SessionSkillUploadResult>;
+    installPartnerSkill(sessionId: string, payload: PartnerSkillInstallPayload, init?: RequestInit): Promise<PartnerSkillInstallResult>;
+}

package/dist/client/resources/solutions.d.ts

@@ -0,0 +1,31 @@
+import type { BizRole, Solution } from "../../react/types/solution.js";
+import type { BladeClient } from "../blade-client.js";
+import type { ExistingSolutionRef, PreparedSolution } from "../types/sdk-profile.js";
+export type ExportedSolutionFile = {
+    blob: Blob;
+    filename: string;
+};
+export declare class SolutionsResource {
+    private client;
+    constructor(client: BladeClient);
+    fetchSolutions(): Promise<Solution[]>;
+    prepareFromZip(file: File | Blob): Promise<PreparedSolution>;
+    ensureFromRegistry(registryId: string): Promise<ExistingSolutionRef>;
+    fetchSolutionFile(solutionId: string, filePath: string): Promise<string>;
+    fetchSolutionBizRoles(solutionId: string, userId?: string): Promise<BizRole[]>;
+    /**
+     * 把编辑会话里的 solution_name/ 打成 zip 并下载。
+     * 返回 Blob 和从 Content-Disposition 解析出来的文件名,
+     * 调用方自己负责触发浏览器下载(<a download> 或 window.URL.createObjectURL)。
+     */
+    exportSolution(sessionId: string): Promise<ExportedSolutionFile>;
+    /**
+     * 把编辑会话里的 solution 打包并发布到 skill_registry 商店。
+     * 后端会打 zip 并 POST 到 registry,这里只传 org + name + overwrite。
+     */
+    publishSolution(sessionId: string, org: string, name: string, overwrite?: boolean): Promise<{
+        success: boolean;
+        solution_id: string;
+        message: string;
+    }>;
+}

package/dist/client/resources/user-preferences.d.ts

@@ -0,0 +1,26 @@
+import type { BladeClient } from "../blade-client.js";
+export type ComputerUpgradeReason = "no_container" | "no_target" | "current_latest" | "up_to_date" | "upgrade_available";
+export interface ComputerUpgradeStatusResponse {
+    upgrade_available: boolean;
+    reason: ComputerUpgradeReason;
+    current_version: string | null;
+    target_version: string | null;
+}
+export interface UpgradeComputerResponse {
+    target_version: string | null;
+    previous_version: string | null;
+    removed_containers: number;
+    removed_volume: boolean;
+    cleared_memo: number;
+}
+export declare class UserPreferencesResource {
+    private client;
+    constructor(client: BladeClient);
+    getUserPreference(key: string): Promise<string | null>;
+    setUserPreference(key: string, value: string): Promise<void>;
+    getPersistentDefault(): Promise<boolean>;
+    setPersistentDefault(value: boolean): Promise<void>;
+    resetComputer(): Promise<void>;
+    getComputerUpgradeStatus(): Promise<ComputerUpgradeStatusResponse>;
+    upgradeComputer(): Promise<UpgradeComputerResponse>;
+}

package/dist/client/rest.d.ts

@@ -0,0 +1,19 @@
+export declare class BladeApiError extends Error {
+    readonly response: Response;
+    readonly status: number;
+    readonly statusText: string;
+    constructor(response: Response, message?: string);
+}
+/**
+ * 从 FastAPI 风格的错误响应中提取 detail 字段，作为用户可读的中文错误文案。
+ * 失败时返回 undefined，调用方会回退到默认提示。
+ */
+export declare function extractErrorDetail(response: Response): Promise<string | undefined>;
+export type HttpMethod = "DELETE" | "GET" | "PATCH" | "POST" | "PUT" | (string & {});
+export interface BladeFetchInit {
+    body?: BodyInit | null;
+    credentials?: RequestCredentials;
+    expectOk?: boolean;
+    headers?: HeadersInit;
+    signal?: AbortSignal | null;
+}

package/dist/client/shared/projection/builder.d.ts

@@ -0,0 +1,59 @@
+import type { TurnProjection } from "../../../react/schemas/projection.js";
+export interface RawEvent {
+    type: string;
+    payload: Record<string, unknown>;
+}
+export type ProjectionUpdate = {
+    kind: "upsert";
+    turn: TurnProjection;
+} | {
+    kind: "workspace_changed";
+    loopId: string;
+    toolCallId?: string;
+    toolName?: string;
+};
+export declare class ClientProjectionBuilder {
+    private activeTurns;
+    private lastTurnIds;
+    private latestTurns;
+    private loopDescriptions;
+    private pendingChildPauses;
+    private pendingMemoryRefs;
+    private activeCompactions;
+    private seq;
+    private syntheticCounter;
+    private displayNameResolver;
+    constructor(displayNameResolver?: (name: string) => string);
+    processBatch(events: RawEvent[]): ProjectionUpdate[];
+    processEvent(event: RawEvent): ProjectionUpdate[] | null;
+    reset(): void;
+    seedSequence(maxSeq: number): void;
+    private onMemoryInject;
+    private onLoopTurn;
+    private onModeChange;
+    private onPlanStatusUpdate;
+    private onWorkspaceChanged;
+    private onAgentStart;
+    private onBgStarted;
+    private onBgTasksCompleted;
+    private onAskUserAnswer;
+    private onUserMessage;
+    private onDelta;
+    private onToolCallCreated;
+    private onResponseDone;
+    private onToolResultDone;
+    private onToolResultDelta;
+    private onToolUi;
+    private onToolBridge;
+    private onToolApprovalRequired;
+    private onChildPause;
+    private onChatEnd;
+    private onAgentEnd;
+    private onCompaction;
+    private syncPatch;
+    private finalize;
+    private shouldFinalizeAfterToolResults;
+    private collectLoopUpdates;
+    private nextSeq;
+    private nextTurnId;
+}

package/dist/client/shared/projection/helpers.d.ts

@@ -0,0 +1,34 @@
+import type { ContentBlock, PendingQuestionRef, ToolCallProjection, TurnProjection } from "../../../react/schemas/projection.js";
+import type { TurnState } from "./state.js";
+export declare function upsertToolCall(state: TurnState, toolCallId: string, toolName: string, displayName: string, args: string): void;
+export declare function applyToolResult(state: TurnState, toolCallId: string, result: unknown, status: ToolCallProjection["status"], durationMs: number | null, sourceLoop: {
+    loop_name: string;
+    description: string;
+} | null): void;
+export declare function appendToolResultDelta(state: TurnState, toolCallId: string, delta: string): void;
+export declare function appendTextBlock(state: TurnState, blockType: ContentBlock["type"], content: unknown): void;
+export declare function appendToolCallArguments(state: TurnState, toolCallId: string, delta: string): void;
+export declare function buildSystemNotificationTurn(sequence: number, turnId: string, loopId: string, notificationType: string, status: string, title: string, detail: string | null, metadata: Record<string, unknown>): TurnProjection;
+export declare function buildSystemNotificationBlock(notificationType: string, status: string, title: string, detail: string | null, metadata: Record<string, unknown>): ContentBlock;
+export declare function buildMarkerTurn(sequence: number, turnId: string, loopId: string, blockType: ContentBlock["type"], content: unknown): TurnProjection;
+export declare function buildCompactionTurn(sequence: number, compactionId: string, loopId: string, status: TurnProjection["status"], data: Record<string, unknown>): TurnProjection;
+export interface ChildPauseInfo {
+    parentLoopName: string;
+    parentToolCallId: string;
+    childLoopName: string;
+    childToolCallId: string;
+    description: string;
+}
+export declare function setToolCallStatus(turn: TurnState | TurnProjection | null | undefined, toolCallId: string, status: ToolCallProjection["status"], result: unknown, pendingQuestionRef: PendingQuestionRef | null): void;
+export declare function applyAskUserPauseToTurn(turn: TurnState | TurnProjection | null | undefined, pauseToolData: Record<string, unknown>, toolCallId: string, childLoopName: string, description: string, displayNameResolver: (name: string) => string): void;
+export declare function applyChildPauseToParent(parentTurn: TurnState | TurnProjection | null | undefined, parentToolCallId: string, childLoopName: string, childToolCallId: string, description: string, displayNameResolver: (name: string) => string): void;
+export declare function sourceLoopFor(loopId: string, loopDescriptions: Map<string, string>): {
+    loop_name: string;
+    description: string;
+} | null;
+export declare function normalizeChildPause(pausePayload: Record<string, unknown>): {
+    pauseToolData: Record<string, unknown>;
+    childLoopName: string;
+    childToolCallId: string;
+    description: string;
+};

package/dist/client/shared/projection/history.d.ts

@@ -0,0 +1,12 @@
+import type { TurnProjection } from "../../../react/schemas/projection.js";
+export interface RawHistoryEntry {
+    id?: string;
+    kind?: string;
+    loop_name?: string;
+    message?: Record<string, unknown>;
+    data?: Record<string, unknown>;
+    timestamp?: string;
+    [key: string]: unknown;
+}
+/** Rebuild completed UI turns from raw persisted history entries. */
+export declare function projectHistory(entries: RawHistoryEntry[]): TurnProjection[];

package/dist/client/shared/projection/index.d.ts

@@ -0,0 +1,3 @@
+export { ClientProjectionBuilder, type RawEvent, type ProjectionUpdate } from "./builder.js";
+export { type TurnState, createTurnState, snapshot, PAUSE_TOOL_NAMES } from "./state.js";
+export { projectHistory, type RawHistoryEntry } from "./history.js";

package/dist/client/shared/projection/state.d.ts

@@ -0,0 +1,22 @@
+import type { ContentBlock, MemoryRef, ToolCallProjection, TurnProjection } from "../../../react/schemas/projection.js";
+export interface TurnState {
+    turnId: string;
+    loopId: string;
+    role: "user" | "assistant" | "system";
+    model: string | null;
+    startedAt: number;
+    contextWindow: number;
+    blocks: ContentBlock[];
+    toolCalls: ToolCallProjection[];
+    usage: Record<string, unknown> | null;
+    memoryRefs: MemoryRef[] | null;
+    parentForkToolCallId: string | null;
+}
+export declare function createTurnState(turnId: string, loopId: string, opts?: {
+    model?: string | null;
+    contextWindow?: number;
+    memoryRefs?: MemoryRef[] | null;
+}): TurnState;
+export declare function snapshot(state: TurnState, sequence: number, status: TurnProjection["status"]): TurnProjection;
+export declare const PAUSE_TOOL_NAMES: Set<string>;
+export declare function toolStatusFromResult(result: unknown): ToolCallProjection["status"];

package/dist/client/socket.d.ts

@@ -0,0 +1,9 @@
+import { type Socket } from "socket.io-client";
+import { type AuthOptions } from "./auth.js";
+import type { ClientToServerEvents, ServerToClientEvents } from "./types/socket-events.js";
+export type TypedSocket = Socket<ServerToClientEvents, ClientToServerEvents>;
+export interface CreateSocketOptions extends AuthOptions {
+    baseUrl: string;
+    path?: string;
+}
+export declare function createSocket(options: CreateSocketOptions): TypedSocket;

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

@@ -0,0 +1,8 @@
+import type { components, paths } from "./rest.js";
+import type { ChatEndPayload, ChatSendPayload, ClientToServerEvents, ServerToClientEvents, SessionUpdatedPayload, SystemErrorPayload, SystemNotificationPayload } from "./socket-events.js";
+export type RestPaths = paths;
+export type RestComponents = components;
+export type Session = paths["/api/sessions/{session_id}"]["get"]["responses"]["200"]["content"]["application/json"];
+export type SessionList = paths["/api/sessions"]["get"]["responses"]["200"]["content"]["application/json"];
+export type SkillList = paths["/api/skills"]["get"]["responses"]["200"]["content"]["application/json"];
+export type { ChatEndPayload, ChatSendPayload, ClientToServerEvents, ServerToClientEvents, SessionUpdatedPayload, SystemErrorPayload, SystemNotificationPayload, };