@blade-hq/agent-kit 1.0.33 → 1.0.35

package/dist/{chunk-E7FQV4IX.js → chunk-ZPPYDQPU.js}

@@ -1,7 +1,7 @@
 import {
   getSessionFilePath,
   resolveSessionFilePreviewTarget
-} from "./chunk-OICNN4K4.js";
+} from "./chunk-J6H4TMTH.js";
 import {
   CardJSON,
   cardRegistry
@@ -11,7 +11,7 @@ import {
   formatToolName,
   getAuthedUrl,
   useUiStore
-} from "./chunk-IDVNG3YJ.js";
+} from "./chunk-YJSN44Q4.js";
 import {
   cn,
   copyToClipboard
@@ -2065,4 +2065,4 @@ export {
   PlanSummaryCard,
   extractLatestPlanMessages
 };
-//# sourceMappingURL=chunk-E7FQV4IX.js.map
+//# sourceMappingURL=chunk-ZPPYDQPU.js.map

package/dist/client/auth.d.ts

@@ -1,3 +1,5 @@
+import type { BladeClient } from "./blade-client.js";
+import { type BladeAuthenticatedUser, type BladeConnectionSnapshot, type BladePopupOptions, type BladeServiceInfo } from "./connection.js";
 export interface AuthOptions {
     token?: string | (() => string | null | undefined);
 }
@@ -6,3 +8,56 @@ export declare function buildSocketAuth(options: AuthOptions): {
     token: string;
 } | undefined;
 export declare function resolveAuthToken(options: AuthOptions): string | null;
+export interface UserInfo extends BladeAuthenticatedUser {
+    token: string;
+    auth_type: "casdoor" | "api_key";
+    is_admin?: boolean;
+}
+export interface ProvidersResponse {
+    providers: Array<{
+        name: string;
+        authorize_url: string;
+    }>;
+    password_enabled: boolean;
+}
+export declare class AuthResource {
+    private client;
+    private readonly listeners;
+    private readonly memoryStorage;
+    private storage;
+    private persistent;
+    private restorePromise;
+    private baseUrlGeneration;
+    private pendingConnection;
+    private activePopup;
+    private cancelPending;
+    private snapshot;
+    constructor(client: BladeClient);
+    getProviders(): Promise<ProvidersResponse>;
+    getMe(): Promise<UserInfo>;
+    logout(): Promise<{
+        logout_url: string;
+    }>;
+    getConnectionSnapshot(): BladeConnectionSnapshot;
+    subscribe(listener: () => void): () => void;
+    probe(): Promise<BladeServiceInfo>;
+    restore(): Promise<BladeConnectionSnapshot>;
+    private runRestore;
+    retry(): Promise<BladeConnectionSnapshot>;
+    connectWithPopup(options?: BladePopupOptions): Promise<BladeAuthenticatedUser>;
+    disconnect(): Promise<void>;
+    _handleUnauthorized(): Promise<void>;
+    _handleBaseUrlChange(): Promise<void>;
+    private runPopupFlow;
+    private waitForPopup;
+    private assertNoMixedContent;
+    private assertGeneration;
+    private url;
+    private storageKey;
+    private storageGet;
+    private storageSet;
+    private clearManagedAuth;
+    private useMemoryStorage;
+    private update;
+    private toConnectionError;
+}

package/dist/client/blade-client.d.ts

@@ -16,18 +16,25 @@ import { SkillsResource } from "./resources/skills.js";
 import { SolutionsResource } from "./resources/solutions.js";
 import { UserPreferencesResource } from "./resources/user-preferences.js";
 import { type TypedSocket } from "./socket.js";
+import type { BladeAuthStorage } from "./connection.js";
 export interface BladeClientOptions {
-    baseUrl: string;
+    baseUrl?: string;
+    port?: number;
     token?: string | (() => string | null | undefined);
+    authStorage?: BladeAuthStorage | false;
     fetchImpl?: typeof fetch;
     onRefreshSuccess?: () => void | Promise<void>;
 }
 export declare class BladeClient {
     private refreshPromise;
     private socketInstance;
+    private managedToken;
+    private readonly baseUrlChangeListeners;
     private storeRestTokenResolver;
     private storeSocketTokenResolver;
-    readonly options: BladeClientOptions;
+    readonly options: BladeClientOptions & {
+        baseUrl: string;
+    };
     readonly apiKeys: ApiKeysResource;
     readonly appDevTemplates: AppDevTemplatesResource;
     readonly auth: AuthResource;
@@ -44,10 +51,15 @@ export declare class BladeClient {
     readonly skills: SkillsResource;
     readonly solutions: SolutionsResource;
     readonly userPreferences: UserPreferencesResource;
-    constructor(options: BladeClientOptions);
+    constructor(options?: BladeClientOptions);
     _attachStoreRestTokenResolver(fn: () => string | null | undefined): void;
     _attachStoreSocketTokenResolver(fn: () => string | null | undefined): void;
     setBaseUrl(baseUrl: string): void;
+    onBaseUrlChange(listener: () => void): () => void;
+    get baseUrl(): string;
+    _setManagedToken(token: string | null): void;
+    _reconnectSocketWithCurrentAuth(): void;
+    _disconnectSocket(): void;
     socket(): TypedSocket;
     json<T>(method: HttpMethod, path: string, body?: unknown): Promise<T>;
     jsonFromInit<T>(path: string, init?: RequestInit): Promise<T>;
@@ -67,12 +79,15 @@ export declare class BladeClient {
     private toBaseRelativePath;
     private isSameBackendUrl;
     private shouldRefreshFor401;
+    private defaultCredentials;
+    private shouldOmitManagedCredentials;
     private hasExplicitBearerToken;
     private tryRefresh;
     private resolveTokenForUrl;
     private resolveRestToken;
     private resolveSocketToken;
     private resolveToken;
+    private resolveConfiguredToken;
     private formDataWithUploadProgress;
 }
 export interface UploadProgress {
@@ -80,3 +95,4 @@ export interface UploadProgress {
     total?: number;
     percent?: number;
 }
+export declare function resolveBladeBaseUrl(options?: Pick<BladeClientOptions, "baseUrl" | "port">): string;

package/dist/client/connection.d.ts

@@ -0,0 +1,41 @@
+export interface BladeAuthenticatedUser {
+    id: string;
+    username: string;
+    display_name?: string | null;
+    avatar_url: string | null;
+}
+export interface BladeStoredAuth {
+    accessToken: string;
+    user: BladeAuthenticatedUser;
+    savedAt: string;
+}
+export interface BladeAuthStorage {
+    get(key: string): BladeStoredAuth | null | Promise<BladeStoredAuth | null>;
+    set(key: string, value: BladeStoredAuth): void | Promise<void>;
+    remove(key: string): void | Promise<void>;
+}
+export type BladeConnectionStatus = "checking_service" | "service_unavailable" | "signed_out" | "waiting_for_authorization" | "connecting" | "connected" | "expired" | "configuration_error";
+export type BladeConnectionErrorCode = "invalid_url" | "service_unreachable" | "not_blade_agent" | "incompatible_server" | "mixed_content" | "popup_blocked" | "popup_closed" | "authorization_denied" | "authorization_expired" | "origin_mismatch" | "invalid_credentials" | "token_exchange_failed";
+export declare class BladeConnectionError extends Error {
+    readonly code: BladeConnectionErrorCode;
+    constructor(code: BladeConnectionErrorCode, message: string, options?: ErrorOptions);
+}
+export interface BladeConnectionSnapshot {
+    status: BladeConnectionStatus;
+    baseUrl: string;
+    user: BladeAuthenticatedUser | null;
+    error: BladeConnectionError | null;
+    persistent: boolean;
+    managedBySdk: boolean;
+}
+export interface BladeServiceInfo {
+    status: "ok";
+    service: "blade-agent";
+    sdk_auth_version: "1";
+}
+export interface BladePopupOptions {
+    timeoutMs?: number;
+    windowFeatures?: string;
+}
+export declare function createMemoryAuthStorage(): BladeAuthStorage;
+export declare function createLocalAuthStorage(): BladeAuthStorage;

package/dist/client/index.d.ts

@@ -4,6 +4,9 @@ export { BladeApiError } from "./rest.js";
 export type { BladeFetchInit, HttpMethod } from "./rest.js";
 export { createSocket } from "./socket.js";
 export type { CreateSocketOptions, TypedSocket } from "./socket.js";
+export { resolveBladeBaseUrl } from "./blade-client.js";
+export { BladeConnectionError, createLocalAuthStorage, createMemoryAuthStorage, } from "./connection.js";
+export type { BladeAuthenticatedUser, BladeAuthStorage, BladeConnectionErrorCode, BladeConnectionSnapshot, BladeConnectionStatus, BladePopupOptions, BladeServiceInfo, BladeStoredAuth, } from "./connection.js";
 export * from "./resources/api-keys.js";
 export * from "./resources/app-dev-templates.js";
 export * from "./resources/auth.js";

package/dist/client/index.js

@@ -4,6 +4,7 @@ import {
   AuthResource,
   BladeApiError,
   BladeClient,
+  BladeConnectionError,
   GisResource,
   HeadlessError,
   HeadlessResource,
@@ -20,9 +21,12 @@ import {
   SkillsResource,
   SolutionsResource,
   UserPreferencesResource,
+  createLocalAuthStorage,
+  createMemoryAuthStorage,
   createSocket,
-  normalizeResource
-} from "../chunk-FK4CV6R2.js";
+  normalizeResource,
+  resolveBladeBaseUrl
+} from "../chunk-C63X3RCM.js";
 import "../chunk-PZ5AY32C.js";
 export {
   ApiKeysResource,
@@ -30,6 +34,7 @@ export {
   AuthResource,
   BladeApiError,
   BladeClient,
+  BladeConnectionError,
   GisResource,
   HeadlessError,
   HeadlessResource,
@@ -46,7 +51,10 @@ export {
   SkillsResource,
   SolutionsResource,
   UserPreferencesResource,
+  createLocalAuthStorage,
+  createMemoryAuthStorage,
   createSocket,
-  normalizeResource
+  normalizeResource,
+  resolveBladeBaseUrl
 };
 //# sourceMappingURL=index.js.map

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

@@ -1,26 +1 @@
-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;
-    }>;
-}
+export { AuthResource, type ProvidersResponse, type UserInfo, } from "../auth.js";

package/dist/client/socket.d.ts

@@ -5,5 +5,6 @@ export type TypedSocket = Socket<ServerToClientEvents, ClientToServerEvents>;
 export interface CreateSocketOptions extends AuthOptions {
     baseUrl: string;
     path?: string;
+    withCredentials?: boolean;
 }
 export declare function createSocket(options: CreateSocketOptions): TypedSocket;

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

@@ -305,6 +305,41 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/auth/sdk/authorize": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Authorize Sdk */
+        get: operations["authorize_sdk_api_auth_sdk_authorize_get"];
+        put?: never;
+        /** Confirm Sdk Authorization */
+        post: operations["confirm_sdk_authorization_api_auth_sdk_authorize_post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/auth/sdk/token": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Exchange Sdk Token */
+        post: operations["exchange_sdk_token_api_auth_sdk_token_post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/browser-extension/sessions": {
         parameters: {
             query?: never;
@@ -1939,7 +1974,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/admin/model-config/{config_id}": {
+    "/api/admin/model-config/models/{model_id}": {
         parameters: {
             query?: never;
             header?: never;
@@ -1948,16 +1983,16 @@ export interface paths {
         };
         get?: never;
         /** Update Model Config */
-        put: operations["update_model_config_api_admin_model_config__config_id__put"];
+        put: operations["update_model_config_api_admin_model_config_models__model_id__put"];
         post?: never;
         /** Delete Model Config */
-        delete: operations["delete_model_config_api_admin_model_config__config_id__delete"];
+        delete: operations["delete_model_config_api_admin_model_config_models__model_id__delete"];
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/admin/model-config/{config_id}/default": {
+    "/api/admin/model-config/default": {
         parameters: {
             query?: never;
             header?: never;
@@ -1966,7 +2001,24 @@ export interface paths {
         };
         get?: never;
         /** Set Default Model Config */
-        put: operations["set_default_model_config_api_admin_model_config__config_id__default_put"];
+        put: operations["set_default_model_config_api_admin_model_config_default_put"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/admin/model-config/default/reset": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        /** Clear Default Model Config */
+        put: operations["clear_default_model_config_api_admin_model_config_default_reset_put"];
         post?: never;
         delete?: never;
         options?: never;
@@ -5528,10 +5580,29 @@ export interface components {
             service: components["schemas"]["ModelServiceResponse"];
             /** Items */
             items: components["schemas"]["ModelConfigResponse"][];
-            /** Default Config Id */
-            default_config_id: string;
+            /** Default Model Id */
+            default_model_id: string;
+            /** Default Source */
+            default_source: string;
+            /** Admin Default Model Id */
+            admin_default_model_id?: string | null;
+            /**
+             * Admin Default Available
+             * @default false
+             */
+            admin_default_available: boolean;
             /** Source */
             source: string;
+            /**
+             * Catalog Incomplete
+             * @default false
+             */
+            catalog_incomplete: boolean;
+            /**
+             * Catalog Stale
+             * @default false
+             */
+            catalog_stale: boolean;
         };
         /** ModelConfigInput */
         ModelConfigInput: {
@@ -5542,6 +5613,13 @@ export interface components {
             /** Id */
             id: string;
             model: components["schemas"]["ModelDetailsResponse"];
+            /** Source */
+            source: string;
+            /**
+             * Overridden
+             * @default false
+             */
+            overridden: boolean;
         };
         /** ModelConfigTestResponse */
         ModelConfigTestResponse: {
@@ -5557,7 +5635,7 @@ export interface components {
             /** Id */
             id: string;
             /** Context Window */
-            context_window: number;
+            context_window?: number | null;
             /**
              * Supports Vision
              * @default true
@@ -5568,6 +5646,8 @@ export interface components {
         ModelDetailsResponse: {
             /** Id */
             id: string;
+            /** Label */
+            label: string;
             /** Context Window */
             context_window: number;
             /** Supports Vision */
@@ -5609,6 +5689,12 @@ export interface components {
              * @enum {string}
              */
             thinking_request_format: "auto" | "none" | "openai_reasoning_effort" | "openrouter_reasoning" | "deepseek_thinking" | "together_reasoning" | "zai_thinking" | "qwen_enable_thinking" | "sglang_chat_template";
+            /**
+             * Auth Mode
+             * @default fixed_key
+             * @enum {string}
+             */
+            auth_mode: "current_user" | "fixed_key" | "none";
         };
         /** ModelServiceResponse */
         ModelServiceResponse: {
@@ -5628,6 +5714,11 @@ export interface components {
              * @enum {string}
              */
             effective_thinking_request_format: "none" | "openai_reasoning_effort" | "openrouter_reasoning" | "deepseek_thinking" | "together_reasoning" | "zai_thinking" | "qwen_enable_thinking" | "sglang_chat_template";
+            /**
+             * Auth Mode
+             * @enum {string}
+             */
+            auth_mode: "current_user" | "fixed_key" | "none";
         };
         /** ModelsConfig */
         ModelsConfig: {
@@ -5960,6 +6051,37 @@ export interface components {
             /** Model */
             model?: string | null;
         };
+        /** SdkAuthorizedUser */
+        SdkAuthorizedUser: {
+            /** Id */
+            id: string;
+            /** Username */
+            username: string;
+            /** Display Name */
+            display_name: string;
+            /** Avatar Url */
+            avatar_url: string | null;
+        };
+        /** SdkTokenRequest */
+        SdkTokenRequest: {
+            /** Code */
+            code: string;
+            /** State */
+            state: string;
+            /** Client Origin */
+            client_origin: string;
+        };
+        /** SdkTokenResponse */
+        SdkTokenResponse: {
+            /** Access Token */
+            access_token: string;
+            /**
+             * Token Type
+             * @default Bearer
+             */
+            token_type: string;
+            user: components["schemas"]["SdkAuthorizedUser"];
+        };
         /** SessionMemoryRequest */
         SessionMemoryRequest: {
             /** Memory Enabled */
@@ -7127,6 +7249,91 @@ export interface operations {
             };
         };
     };
+    authorize_sdk_api_auth_sdk_authorize_get: {
+        parameters: {
+            query: {
+                client_origin: string;
+                state: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    confirm_sdk_authorization_api_auth_sdk_authorize_post: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+        };
+    };
+    exchange_sdk_token_api_auth_sdk_token_post: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["SdkTokenRequest"];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SdkTokenResponse"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
     list_extension_sessions_api_browser_extension_sessions_get: {
         parameters: {
             query?: {
@@ -10393,12 +10600,12 @@ export interface operations {
             };
         };
     };
-    update_model_config_api_admin_model_config__config_id__put: {
+    update_model_config_api_admin_model_config_models__model_id__put: {
         parameters: {
             query?: never;
             header?: never;
             path: {
-                config_id: string;
+                model_id: string;
             };
             cookie?: never;
         };
@@ -10428,12 +10635,12 @@ export interface operations {
             };
         };
     };
-    delete_model_config_api_admin_model_config__config_id__delete: {
+    delete_model_config_api_admin_model_config_models__model_id__delete: {
         parameters: {
             query?: never;
             header?: never;
             path: {
-                config_id: string;
+                model_id: string;
             };
             cookie?: never;
         };
@@ -10459,16 +10666,18 @@ export interface operations {
             };
         };
     };
-    set_default_model_config_api_admin_model_config__config_id__default_put: {
+    set_default_model_config_api_admin_model_config_default_put: {
         parameters: {
             query?: never;
             header?: never;
-            path: {
-                config_id: string;
-            };
+            path?: never;
             cookie?: never;
         };
-        requestBody?: never;
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ModelProbeRequest"];
+            };
+        };
         responses: {
             /** @description Successful Response */
             200: {
@@ -10490,6 +10699,26 @@ export interface operations {
             };
         };
     };
+    clear_default_model_config_api_admin_model_config_default_reset_put: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ModelConfigCollectionResponse"];
+                };
+            };
+        };
+    };
     list_model_candidates_api_admin_model_config_candidates_post: {
         parameters: {
             query?: never;

package/dist/client/types/socket-events.d.ts

@@ -166,11 +166,15 @@ export declare namespace SessionUpdatedPayloadSchema {
         [k: string]: unknown;
     } | null);
     type Intent = (string | null);
+    type ProjectId = (number | null);
+    type ProjectName = (string | null);
     interface SessionUpdatedPayload {
         session_id: SessionId;
         model?: Model;
         replay_state?: ReplayState;
         intent?: Intent;
+        project_id?: ProjectId;
+        project_name?: ProjectName;
         [k: string]: unknown;
     }
 }