@blade-hq/agent-kit 1.0.24 → 1.0.27

package/dist/client/index.js

@@ -17,13 +17,11 @@ import {
   ScenariosResource,
   SessionsResource,
   SkillsResource,
-  SoftwareFactoryResource,
   SolutionsResource,
   UserPreferencesResource,
-  VibeCodingResource,
   createSocket,
   normalizeResource
-} from "../chunk-7F6UP5LP.js";
+} from "../chunk-34GDDOWY.js";
 import "../chunk-PZ5AY32C.js";
 export {
   ApiKeysResource,
@@ -44,10 +42,8 @@ export {
   ScenariosResource,
   SessionsResource,
   SkillsResource,
-  SoftwareFactoryResource,
   SolutionsResource,
   UserPreferencesResource,
-  VibeCodingResource,
   createSocket,
   normalizeResource
 };

package/dist/client/resources/api-keys.d.ts

@@ -0,0 +1,28 @@
+import type { BladeClient } from "../blade-client.js";
+export interface ApiKeyPublic {
+    id: string;
+    name: string;
+    masked: string;
+    created_at: string;
+    last_used_at: string | null;
+    /**
+     * 完整 key 原文。后端按 #761 设计存明文，支持反复获取；存量 hash-only 行为 null。
+     */
+    plaintext: string | null;
+    /**
+     * 只读行（如经 bo 经纪人下发的 GIT_ACCESS_TOKEN）：UI 只给复制，不给改名/撤销。
+     */
+    readonly?: boolean;
+}
+export interface ApiKeyCreateResponse {
+    key: ApiKeyPublic;
+    plaintext: string;
+}
+export declare class ApiKeysResource {
+    private client;
+    constructor(client: BladeClient);
+    listApiKeys(): Promise<ApiKeyPublic[]>;
+    createApiKey(name: string): Promise<ApiKeyCreateResponse>;
+    renameApiKey(id: string, name: string): Promise<ApiKeyPublic>;
+    deleteApiKey(id: string): Promise<void>;
+}

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

@@ -0,0 +1,26 @@
+import type { BladeClient } from "../blade-client.js";
+export interface UserInfo {
+    id: string;
+    username: string;
+    display_name?: string | null;
+    avatar_url: string | null;
+    token: string;
+    auth_type: "casdoor";
+    is_admin?: boolean;
+}
+export interface ProvidersResponse {
+    providers: Array<{
+        name: string;
+        authorize_url: string;
+    }>;
+    password_enabled: boolean;
+}
+export declare class AuthResource {
+    private client;
+    constructor(client: BladeClient);
+    getProviders(): Promise<ProvidersResponse>;
+    getMe(): Promise<UserInfo>;
+    logout(): Promise<{
+        logout_url: string;
+    }>;
+}

package/dist/client/resources/env-buckets.d.ts

@@ -0,0 +1,20 @@
+import type { BladeClient } from "../blade-client.js";
+export interface EnvBucket {
+    bucket: string;
+    env: Record<string, string>;
+}
+export interface PlatformEnvBucket {
+    env: Record<string, string>;
+}
+export declare class EnvBucketsResource {
+    private client;
+    constructor(client: BladeClient);
+    listEnvBuckets(): Promise<EnvBucket[]>;
+    getEnvBucket(bucket: string): Promise<EnvBucket>;
+    setEnvBucket(bucket: string, env: Record<string, string>): Promise<EnvBucket>;
+    deleteEnvBucket(bucket: string): Promise<void>;
+    getPlatformEnv(): Promise<PlatformEnvBucket>;
+    getPlatformEnvReadonly(): Promise<PlatformEnvBucket>;
+    setPlatformEnv(env: Record<string, string>): Promise<PlatformEnvBucket>;
+    deletePlatformEnv(): Promise<void>;
+}

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

@@ -0,0 +1,8 @@
+import type { GisState, RuntimeConfig } from "../../react/schemas/gis.js";
+import type { BladeClient } from "../blade-client.js";
+export declare class GisResource {
+    private client;
+    constructor(client: BladeClient);
+    fetchGisState(sessionId: string, init?: RequestInit): Promise<GisState>;
+    fetchRuntimeConfig(init?: RequestInit): Promise<RuntimeConfig>;
+}

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

@@ -0,0 +1,33 @@
+import type { BladeClient } from "../blade-client.js";
+export type JsonSchemaObject = Record<string, unknown>;
+export interface HeadlessRunOptions {
+    schema?: JsonSchemaObject | null;
+    model?: string | null;
+    timeoutMs?: number;
+}
+export interface HeadlessRunInSessionResult<T = unknown> {
+    session_id: string;
+    chat_run_id: string | null;
+    result: T | string;
+}
+export declare class HeadlessError extends Error {
+    readonly detail?: unknown;
+    constructor(message: string, detail?: unknown);
+}
+export declare class HeadlessResource {
+    private client;
+    constructor(client: BladeClient);
+    run<T = unknown>(prompt: string, options: HeadlessRunOptions & {
+        schema: JsonSchemaObject;
+    }): Promise<T>;
+    run(prompt: string, options?: HeadlessRunOptions): Promise<string>;
+    runInSession<T = unknown>(sessionId: string, prompt: string, options: HeadlessRunOptions & {
+        schema: JsonSchemaObject;
+    }): Promise<T>;
+    runInSession(sessionId: string, prompt: string, options?: HeadlessRunOptions): Promise<string>;
+    runWithSession<T = unknown>(prompt: string, options: HeadlessRunOptions & {
+        schema: JsonSchemaObject;
+    }): Promise<HeadlessRunInSessionResult<T>>;
+    runWithSession(prompt: string, options?: HeadlessRunOptions): Promise<HeadlessRunInSessionResult<string>>;
+    private runTracked;
+}

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

@@ -0,0 +1,63 @@
+import type { BladeClient } from "../blade-client.js";
+export interface Memory {
+    id: number;
+    type: "feedback" | "experience";
+    content: string;
+    skill_name: string | null;
+    record_type: "memory" | "skill_comment" | null;
+    scope: string | null;
+    owner: string | null;
+    topic: string | null;
+    mem0_id: string | null;
+    superseded_by: number | null;
+    write_reason: string | null;
+    created_at: string;
+    updated_at: string | null;
+    hit_count: number;
+    last_hit_at: string | null;
+    disabled: boolean;
+    source_session: string;
+}
+export interface MemoryListResponse {
+    items: Memory[];
+    total: number;
+}
+export interface MemoryListParams {
+    keyword?: string;
+    skill_name?: string;
+    type?: string;
+    record_type?: string;
+    scope?: string;
+    owner?: string;
+    topic?: string;
+    status?: string;
+    offset?: number;
+    limit?: number;
+}
+export interface MemoryCreateBody {
+    content: string;
+    type?: "feedback" | "experience";
+    skill_name?: string | null;
+    record_type?: "memory" | "skill_comment" | null;
+    scope?: string | null;
+    owner?: string | null;
+    topic?: string | null;
+    mem0_id?: string | null;
+    write_reason?: string | null;
+}
+export declare class MemoriesResource {
+    private client;
+    constructor(client: BladeClient);
+    createMemory(body: MemoryCreateBody): Promise<Memory>;
+    listMemories(params?: MemoryListParams): Promise<MemoryListResponse>;
+    getMemory(id: number): Promise<Memory>;
+    updateMemory(id: number, body: Partial<MemoryCreateBody>): Promise<Memory>;
+    patchMemory(id: number, disabled: boolean): Promise<Memory>;
+    deleteMemory(id: number): Promise<{
+        ok: boolean;
+    }>;
+    batchMemories(action: "delete" | "disable" | "enable", ids: number[]): Promise<{
+        ok: boolean;
+        count: number;
+    }>;
+}

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

@@ -0,0 +1,23 @@
+import type { BladeClient } from "../blade-client.js";
+export declare const ModelOption: import("arktype/internal/variants/object.ts").ObjectType<{
+    id: string;
+    label: string;
+    inputModalities?: string[] | undefined;
+    supportsImage?: boolean | undefined;
+}, {}>;
+export type ModelOption = typeof ModelOption.infer;
+export declare const ModelsConfig: import("arktype/internal/variants/object.ts").ObjectType<{
+    default: string;
+    models: {
+        id: string;
+        label: string;
+        inputModalities?: string[] | undefined;
+        supportsImage?: boolean | undefined;
+    }[];
+}, {}>;
+export type ModelsConfig = typeof ModelsConfig.infer;
+export declare class ModelsResource {
+    private client;
+    constructor(client: BladeClient);
+    getModelsConfig(init?: RequestInit): Promise<ModelsConfig>;
+}

package/dist/client/resources/published-apps.d.ts

@@ -0,0 +1,8 @@
+import type { PublishedApp, UnpublishAppResponse } from "../../react/schemas/published-apps.js";
+import type { BladeClient } from "../blade-client.js";
+export declare class PublishedAppsResource {
+    private client;
+    constructor(client: BladeClient);
+    listPublishedApps(): Promise<PublishedApp[]>;
+    unpublishApp(sessionId: string, appName?: string): Promise<UnpublishAppResponse>;
+}

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

@@ -0,0 +1,58 @@
+import type { AgentResource } from "../../react/schemas/studio/agent.js";
+import type { DatabaseResource } from "../../react/schemas/studio/database.js";
+import type { KnowledgeResource } from "../../react/schemas/studio/knowledge.js";
+import type { ToolResource } from "../../react/schemas/studio/tool.js";
+import type { BladeClient } from "../blade-client.js";
+export declare const REGISTRY_PREFIX = "/api-registry";
+type RawResourceResponse = {
+    id: number | string;
+    type: string;
+    subtype: string;
+    driver?: string | null;
+    name: string;
+    description: string;
+    tags: string[];
+    config: Record<string, unknown>;
+    status?: string | null;
+    status_message?: string | null;
+    last_checked_at?: string | null;
+    extra?: Record<string, unknown>;
+    capabilities?: string[];
+    actions?: unknown[];
+    created_at?: string;
+    updated_at?: string;
+    [key: string]: unknown;
+};
+export declare function normalizeResource<T extends Record<string, unknown>>(raw: RawResourceResponse): T;
+export type ResourceApi<T extends Record<string, unknown>> = {
+    list(init?: RequestInit): Promise<T[]>;
+    get(id: string, init?: RequestInit): Promise<T>;
+    create(data: Partial<T>, init?: RequestInit): Promise<T>;
+    update(id: string, data: Partial<T>, init?: RequestInit): Promise<T>;
+    delete(id: string, init?: RequestInit): Promise<void>;
+};
+export type SkillOrgOption = {
+    id: string;
+    display_name: string;
+    kind: "personal" | "org";
+    is_mine: boolean;
+};
+export type SkillOrgListResponse = {
+    orgs: string[];
+    org_options?: SkillOrgOption[];
+};
+export declare class RegistryResource {
+    private client;
+    readonly databaseApi: ResourceApi<DatabaseResource>;
+    readonly toolApi: ResourceApi<ToolResource>;
+    readonly knowledgeApi: ResourceApi<KnowledgeResource>;
+    readonly agentApi: ResourceApi<AgentResource>;
+    constructor(client: BladeClient);
+    createResourceApi<T extends Record<string, unknown>>(apiType: string): ResourceApi<T>;
+    listSkillOrgs(): Promise<SkillOrgListResponse>;
+    publishSkill(sessionId: string, org: string): Promise<{
+        success: boolean;
+        skill_id: string;
+    }>;
+}
+export {};

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

@@ -0,0 +1,8 @@
+import type { BladeClient } from "../blade-client.js";
+import type { RunOptions, RunResult, RunTrace } from "../types/sdk-profile.js";
+export declare class RunsResource {
+    private client;
+    constructor(client: BladeClient);
+    run(sessionId: string, message: string, options?: RunOptions): Promise<RunResult>;
+    collectTrace(run: RunResult): Promise<RunTrace>;
+}

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

@@ -0,0 +1,49 @@
+import type { BladeClient } from "../blade-client.js";
+export interface PreviewUrlItem {
+    name: string;
+    url: string;
+}
+export interface QuickScenario {
+    id: number;
+    name: string;
+    prompt_template: string;
+    skills: string[];
+    preview_urls: PreviewUrlItem[];
+    init_script: string;
+    icon: string;
+    created_at: string;
+    updated_at: string;
+}
+export interface BladeHubScenarioResource {
+    resource_id: string;
+    resource_name: string;
+    name: string;
+    description: string;
+    prompt_template: string;
+    skills: string[];
+    preview_urls: PreviewUrlItem[];
+    init_script: string;
+    icon: string;
+    raw?: Record<string, unknown>;
+}
+export interface CreateQuickScenarioPayload {
+    name: string;
+    prompt_template?: string;
+    skills?: string[];
+    preview_urls?: PreviewUrlItem[];
+    init_script?: string;
+    icon?: string;
+}
+export interface UpdateQuickScenarioPayload extends CreateQuickScenarioPayload {
+}
+export declare class ScenariosResource {
+    private client;
+    constructor(client: BladeClient);
+    listQuickScenarios(init?: RequestInit): Promise<QuickScenario[]>;
+    createQuickScenario(payload: CreateQuickScenarioPayload, init?: RequestInit): Promise<QuickScenario>;
+    deleteQuickScenario(scenarioId: number, init?: RequestInit): Promise<{
+        ok: boolean;
+    }>;
+    updateQuickScenario(scenarioId: number, payload: UpdateQuickScenarioPayload, init?: RequestInit): Promise<QuickScenario>;
+    listBladeHubScenarioResources(limit?: number, init?: RequestInit): Promise<BladeHubScenarioResource[]>;
+}

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;
+    }>;
+}