@blade-hq/agent-kit 1.0.25 → 1.0.28

package/dist/client/types/sdk-profile.d.ts

@@ -0,0 +1,47 @@
+export interface ExistingSolutionRef {
+    kind: "existing";
+    solutionId: string;
+    bizRoleId?: string;
+}
+export interface PreparedSolutionAsset {
+    kind: "prepared";
+    assetId: string;
+    bizRoleId?: string;
+}
+export type SolutionRef = ExistingSolutionRef | PreparedSolutionAsset;
+export interface SessionProfile {
+    solution?: SolutionRef;
+    model?: string;
+    compactionRatio?: number;
+    enableThinking?: boolean;
+    memoryEnabled?: boolean;
+    disableTools?: string[];
+    env?: Record<string, string>;
+}
+export interface RunOptions {
+    headless?: boolean;
+    outputSchema?: Record<string, unknown>;
+    runtimeEnv?: Record<string, string>;
+    timeoutMs?: number;
+    trace?: boolean;
+    compactionRatio?: number;
+    model?: string;
+}
+export interface PreparedSolution extends PreparedSolutionAsset {
+    assetId: string;
+    solutionId: string;
+    roles: string[];
+    expiresAt: string;
+}
+export interface RunResult {
+    sessionId: string;
+    chatRunId?: string;
+    result: unknown;
+    events: unknown[];
+}
+export interface RunTrace {
+    events: unknown[];
+    history: unknown[];
+    result: unknown;
+    configSnapshot: Record<string, unknown>;
+}

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

@@ -0,0 +1,389 @@
+export type AsrAudioPayload = ArrayBuffer | Uint8Array;
+export declare namespace ChatSendPayloadSchema {
+    type SessionId = string;
+    type Mode = (("planning" | "executing") | null);
+    type AskuserAnswer = ({
+        [k: string]: unknown;
+    } | null);
+    type Model = (string | null);
+    type ThinkingOverride = (boolean | null);
+    type Headless = boolean;
+    type OutputSchema = ({
+        [k: string]: unknown;
+    } | null);
+    type FromStep = (number | string | null);
+    type Quotes = (unknown[] | null);
+    type DeprecateEntryIds = (string[] | null);
+    type ReplayDecision = (string | null);
+    type RuntimeEnv = ({
+        [k: string]: string;
+    } | null);
+    type CompactionRatio = (number | null);
+    interface ChatSendPayload {
+        session_id: SessionId;
+        message: Message;
+        mode?: Mode;
+        askuser_answer?: AskuserAnswer;
+        model?: Model;
+        thinking_override?: ThinkingOverride;
+        headless?: Headless;
+        output_schema?: OutputSchema;
+        whatif?: (WhatIfPayload | null);
+        replay_decision?: ReplayDecision;
+        runtime_env?: RuntimeEnv;
+        compaction_ratio?: CompactionRatio;
+        [k: string]: unknown;
+    }
+    interface Message {
+        [k: string]: unknown;
+    }
+    interface WhatIfPayload {
+        from_step?: FromStep;
+        quotes?: Quotes;
+        deprecate_entry_ids?: DeprecateEntryIds;
+        [k: string]: unknown;
+    }
+}
+export type ChatSendPayload = ChatSendPayloadSchema.ChatSendPayload;
+export declare namespace ChatStopPayloadSchema {
+    type SessionId = string;
+    interface ChatStopPayload {
+        session_id: SessionId;
+        [k: string]: unknown;
+    }
+}
+export type ChatStopPayload = ChatStopPayloadSchema.ChatStopPayload;
+export declare namespace ChatAppendPayloadSchema {
+    type SessionId = string;
+    type Message = string;
+    interface ChatAppendPayload {
+        session_id: SessionId;
+        message: Message;
+        [k: string]: unknown;
+    }
+}
+export type ChatAppendPayload = ChatAppendPayloadSchema.ChatAppendPayload;
+export declare namespace ChatCompactPayloadSchema {
+    type SessionId = string;
+    interface ChatCompactPayload {
+        session_id: SessionId;
+        [k: string]: unknown;
+    }
+}
+export type ChatCompactPayload = ChatCompactPayloadSchema.ChatCompactPayload;
+export declare namespace SessionSubscribePayloadSchema {
+    type SessionId = string;
+    type Mode = string;
+    type EventFormat = "raw";
+    type AfterSequence = number;
+    type Resume = boolean;
+    interface SessionSubscribePayload {
+        session_id: SessionId;
+        mode?: Mode;
+        event_format?: EventFormat;
+        after_sequence?: AfterSequence;
+        resume?: Resume;
+        [k: string]: unknown;
+    }
+}
+export type SessionSubscribePayload = SessionSubscribePayloadSchema.SessionSubscribePayload;
+export declare namespace SessionSubscribeBatchPayloadSchema {
+    /**
+     * @minItems 1
+     * @maxItems 200
+     */
+    type Sessions = [SessionSubscribe, ...(SessionSubscribe)[]];
+    type SessionId = string;
+    type Mode = string;
+    type EventFormat = "raw";
+    type AfterSequence = number;
+    type Resume = boolean;
+    interface SessionSubscribeBatchPayload {
+        sessions: Sessions;
+        [k: string]: unknown;
+    }
+    interface SessionSubscribe {
+        session_id: SessionId;
+        mode?: Mode;
+        event_format?: EventFormat;
+        after_sequence?: AfterSequence;
+        resume?: Resume;
+        [k: string]: unknown;
+    }
+}
+export type SessionSubscribeBatchPayload = SessionSubscribeBatchPayloadSchema.SessionSubscribeBatchPayload;
+export declare namespace SessionUnsubscribePayloadSchema {
+    type SessionId = string;
+    interface SessionUnsubscribePayload {
+        session_id: SessionId;
+        [k: string]: unknown;
+    }
+}
+export type SessionUnsubscribePayload = SessionUnsubscribePayloadSchema.SessionUnsubscribePayload;
+export declare namespace AgentBoardProjectSubscribePayloadSchema {
+    type ProjectId = number;
+    interface AgentBoardProjectSubscribePayload {
+        project_id: ProjectId;
+        [k: string]: unknown;
+    }
+}
+export type AgentBoardProjectSubscribePayload = AgentBoardProjectSubscribePayloadSchema.AgentBoardProjectSubscribePayload;
+export declare namespace AgentBoardProjectUnsubscribePayloadSchema {
+    type ProjectId = number;
+    interface AgentBoardProjectUnsubscribePayload {
+        project_id: ProjectId;
+        [k: string]: unknown;
+    }
+}
+export type AgentBoardProjectUnsubscribePayload = AgentBoardProjectUnsubscribePayloadSchema.AgentBoardProjectUnsubscribePayload;
+export declare namespace ChatStartPayloadSchema {
+    type SessionId = (string | null);
+    interface ChatStartPayload {
+        session_id?: SessionId;
+        [k: string]: unknown;
+    }
+}
+export type ChatStartPayload = ChatStartPayloadSchema.ChatStartPayload;
+export declare namespace ChatEndPayloadSchema {
+    type SessionId = (string | null);
+    type Status = (string | null);
+    type FinishReason = (string | null);
+    type ChatRunId = (string | null);
+    interface ChatEndPayload {
+        session_id?: SessionId;
+        status?: Status;
+        result?: unknown;
+        finish_reason?: FinishReason;
+        chat_run_id?: ChatRunId;
+        [k: string]: unknown;
+    }
+}
+export type ChatEndPayload = ChatEndPayloadSchema.ChatEndPayload;
+export declare namespace SessionUpdatedPayloadSchema {
+    type SessionId = string;
+    type Model = (string | null);
+    type ReplayState = ({
+        [k: string]: unknown;
+    } | null);
+    type Intent = (string | null);
+    interface SessionUpdatedPayload {
+        session_id: SessionId;
+        model?: Model;
+        replay_state?: ReplayState;
+        intent?: Intent;
+        [k: string]: unknown;
+    }
+}
+export type SessionUpdatedPayload = SessionUpdatedPayloadSchema.SessionUpdatedPayload;
+export declare namespace WorkspaceFilesChangedPayloadSchema {
+    type SessionId = string;
+    type FilePath = (string | null);
+    interface WorkspaceFilesChangedPayload {
+        session_id: SessionId;
+        file_path?: FilePath;
+        [k: string]: unknown;
+    }
+}
+export type WorkspaceFilesChangedPayload = WorkspaceFilesChangedPayloadSchema.WorkspaceFilesChangedPayload;
+export declare namespace SystemErrorPayloadSchema {
+    type Message = string;
+    type SessionId = (string | null);
+    type Code = (string | number | null);
+    interface SystemErrorPayload {
+        message: Message;
+        session_id?: SessionId;
+        code?: Code;
+        detail?: Detail;
+        [k: string]: unknown;
+    }
+    interface Detail {
+        [k: string]: unknown;
+    }
+}
+export type SystemErrorPayload = SystemErrorPayloadSchema.SystemErrorPayload;
+export declare namespace SystemNotificationPayloadSchema {
+    type SessionId = (string | null);
+    type NotificationType = string;
+    type Title = string;
+    type Detail = (string | null);
+    type Status = (string | null);
+    type Metadata = ({
+        [k: string]: unknown;
+    } | null);
+    interface SystemNotificationPayload {
+        session_id?: SessionId;
+        notification_type: NotificationType;
+        title: Title;
+        detail?: Detail;
+        status?: Status;
+        metadata?: Metadata;
+        [k: string]: unknown;
+    }
+}
+export type SystemNotificationPayload = SystemNotificationPayloadSchema.SystemNotificationPayload;
+export declare namespace TurnEventsPayloadSchema {
+    type SessionId = string;
+    type Type = string;
+    type StreamSequence = (number | null);
+    type Events = RawWireEvent[];
+    interface TurnEventsPayload {
+        session_id: SessionId;
+        events: Events;
+        [k: string]: unknown;
+    }
+    interface RawWireEvent {
+        type: Type;
+        payload: Payload;
+        stream_sequence?: StreamSequence;
+        [k: string]: unknown;
+    }
+    interface Payload {
+        [k: string]: unknown;
+    }
+}
+export type TurnEventsPayload = TurnEventsPayloadSchema.TurnEventsPayload;
+export declare namespace AsrReadyPayloadSchema {
+    type RequestId = string;
+    type Provider = string;
+    interface AsrReadyPayload {
+        request_id: RequestId;
+        provider: Provider;
+        [k: string]: unknown;
+    }
+}
+export type AsrReadyPayload = AsrReadyPayloadSchema.AsrReadyPayload;
+export declare namespace AsrTextPayloadSchema {
+    type Text = string;
+    type RequestId = (string | null);
+    interface AsrTextPayload {
+        text: Text;
+        request_id?: RequestId;
+        [k: string]: unknown;
+    }
+}
+export type AsrTextPayload = AsrTextPayloadSchema.AsrTextPayload;
+export declare namespace AsrClosedPayloadSchema {
+    type RequestId = string;
+    interface AsrClosedPayload {
+        request_id: RequestId;
+        [k: string]: unknown;
+    }
+}
+export type AsrClosedPayload = AsrClosedPayloadSchema.AsrClosedPayload;
+export declare namespace AsrErrorPayloadSchema {
+    type Message = string;
+    type RequestId = (string | null);
+    interface AsrErrorPayload {
+        message: Message;
+        request_id?: RequestId;
+        [k: string]: unknown;
+    }
+}
+export type AsrErrorPayload = AsrErrorPayloadSchema.AsrErrorPayload;
+export declare namespace AgentBoardBoardTaskChangedPayloadSchema {
+    type ProjectId = number;
+    type Action = ("created" | "updated" | "deleted");
+    interface AgentBoardBoardTaskChangedPayload {
+        project_id: ProjectId;
+        action: Action;
+        task: Task;
+        [k: string]: unknown;
+    }
+    interface Task {
+        [k: string]: unknown;
+    }
+}
+export type AgentBoardBoardTaskChangedPayload = AgentBoardBoardTaskChangedPayloadSchema.AgentBoardBoardTaskChangedPayload;
+export declare namespace AgentBoardFileOpPayloadSchema {
+    type ProjectId = number;
+    type SessionId = string;
+    type ToolCallId = (string | null);
+    type Action = string;
+    type FilePath = string;
+    type Description = (string | null);
+    type ContentPreview = (string | null);
+    type FinalContent = (string | null);
+    type ContentDelta = (boolean | null);
+    type IsFinal = (boolean | null);
+    type CreatedAt = string;
+    interface AgentBoardFileOpPayload {
+        project_id: ProjectId;
+        session_id: SessionId;
+        tool_call_id?: ToolCallId;
+        action: Action;
+        file_path: FilePath;
+        description?: Description;
+        content_preview?: ContentPreview;
+        final_content?: FinalContent;
+        content_delta?: ContentDelta;
+        is_final?: IsFinal;
+        created_at: CreatedAt;
+        [k: string]: unknown;
+    }
+}
+export type AgentBoardFileOpPayload = AgentBoardFileOpPayloadSchema.AgentBoardFileOpPayload;
+export declare namespace ChatStopAckSchema {
+    type Status = string;
+    type Message = (string | null);
+    type Code = (string | number | null);
+    interface ChatStopAck {
+        status: Status;
+        message?: Message;
+        code?: Code;
+        [k: string]: unknown;
+    }
+}
+export type ChatStopAck = ChatStopAckSchema.ChatStopAck;
+export declare namespace ChatCompactAckSchema {
+    type Status = string;
+    type Message = (string | null);
+    type Code = (string | number | null);
+    interface ChatCompactAck {
+        status: Status;
+        message?: Message;
+        code?: Code;
+        [k: string]: unknown;
+    }
+}
+export type ChatCompactAck = ChatCompactAckSchema.ChatCompactAck;
+export interface ClientToServerEvents {
+    "chat:send": (payload: ChatSendPayload) => void;
+    "chat:stop": (payload: ChatStopPayload, ack: (response: ChatStopAck) => void) => void;
+    "chat:append": (payload: ChatAppendPayload) => void;
+    "chat:compact": (payload: ChatCompactPayload, ack: (response: ChatCompactAck) => void) => void;
+    "session:subscribe": (payload: SessionSubscribePayload) => void;
+    "session:subscribe_batch": (payload: SessionSubscribeBatchPayload) => void;
+    "session:unsubscribe": (payload: SessionUnsubscribePayload) => void;
+    "agent-board:project:subscribe": (payload: AgentBoardProjectSubscribePayload) => void;
+    "agent-board:project:unsubscribe": (payload: AgentBoardProjectUnsubscribePayload) => void;
+    "asr:start": (payload: unknown) => void;
+    "asr:audio": (payload: AsrAudioPayload) => void;
+    "asr:stop": (payload: unknown) => void;
+    "gis.event.analysis.request": (payload: unknown, ack: (response: unknown) => void) => void;
+}
+export interface ServerToClientEvents {
+    "chat:start": (payload: ChatStartPayload) => void;
+    "chat:end": (payload: ChatEndPayload) => void;
+    "chat:append:ack": (payload: unknown) => void;
+    "session:updated": (payload: SessionUpdatedPayload) => void;
+    "workspace:files_changed": (payload: WorkspaceFilesChangedPayload) => void;
+    "system:error": (payload: SystemErrorPayload) => void;
+    "system:notification": (payload: SystemNotificationPayload) => void;
+    "turn:events": (payload: TurnEventsPayload) => void;
+    "task:updated": (payload: unknown) => void;
+    "task:synced": (payload: unknown) => void;
+    "artifact:created": (payload: unknown) => void;
+    "artifact:updated": (payload: unknown) => void;
+    "bg:started": (payload: unknown) => void;
+    "bg:tasks_completed": (payload: unknown) => void;
+    "skills:changed": (payload: unknown) => void;
+    "session:rewind": (payload: unknown) => void;
+    "asr:ready": (payload: AsrReadyPayload) => void;
+    "asr:partial": (payload: AsrTextPayload) => void;
+    "asr:final": (payload: AsrTextPayload) => void;
+    "asr:closed": (payload: AsrClosedPayload) => void;
+    "asr:error": (payload: AsrErrorPayload) => void;
+    "replay:input_mismatch": (payload: unknown) => void;
+    "agent-board:board-task:changed": (payload: AgentBoardBoardTaskChangedPayload) => void;
+    "agent-board:file-op": (payload: AgentBoardFileOpPayload) => void;
+}

package/dist/react/api/api-keys.d.ts

@@ -0,0 +1,6 @@
+import type { ApiKeysResource } from "../../client/resources/api-keys.js";
+export type * from "../../client/resources/api-keys.js";
+export declare const listApiKeys: (...args: Parameters<ApiKeysResource["listApiKeys"]>) => Promise<import("./api-keys.js").ApiKeyPublic[]>;
+export declare const createApiKey: (...args: Parameters<ApiKeysResource["createApiKey"]>) => Promise<import("./api-keys.js").ApiKeyCreateResponse>;
+export declare const renameApiKey: (...args: Parameters<ApiKeysResource["renameApiKey"]>) => Promise<import("./api-keys.js").ApiKeyPublic>;
+export declare const deleteApiKey: (...args: Parameters<ApiKeysResource["deleteApiKey"]>) => Promise<void>;

package/dist/react/api/app-dev-templates.d.ts

@@ -0,0 +1,5 @@
+import type { AppDevTemplatesResource } from "../../client/resources/app-dev-templates.js";
+export type * from "../../client/resources/app-dev-templates.js";
+export declare const list: (...args: Parameters<AppDevTemplatesResource["list"]>) => Promise<import("./app-dev-templates.js").AppDevTemplateListResponse>;
+export declare const get: (...args: Parameters<AppDevTemplatesResource["get"]>) => Promise<import("./app-dev-templates.js").AppDevTemplateDetail>;
+export declare const getMediaUrl: (...args: Parameters<AppDevTemplatesResource["getMediaUrl"]>) => string;

package/dist/react/api/auth.d.ts

@@ -0,0 +1,7 @@
+import type { AuthResource } from "../../client/resources/auth.js";
+export type * from "../../client/resources/auth.js";
+export declare const getProviders: (...args: Parameters<AuthResource["getProviders"]>) => Promise<import("./auth.js").ProvidersResponse>;
+export declare const getMe: (...args: Parameters<AuthResource["getMe"]>) => Promise<import("./auth.js").UserInfo>;
+export declare const logout: (...args: Parameters<AuthResource["logout"]>) => Promise<{
+    logout_url: string;
+}>;

package/dist/react/api/client.d.ts

@@ -0,0 +1,8 @@
+import type { BladeClient, BladeClientOptions } from "../../client/index.js";
+export declare function getBaseUrl(): string;
+export declare function getAuthedUrl(path: string): string;
+export declare function apiFetch<T>(path: string, init?: RequestInit): Promise<T>;
+export declare function apiFetchText(path: string, init?: RequestInit): Promise<string>;
+export declare function apiFetchResponse(path: string, init?: RequestInit): Promise<Response>;
+export declare function getClient(): BladeClient;
+export type { BladeClientOptions };

package/dist/react/api/env-buckets.d.ts

@@ -0,0 +1,10 @@
+import type { EnvBucketsResource } from "../../client/resources/env-buckets.js";
+export type * from "../../client/resources/env-buckets.js";
+export declare const listEnvBuckets: (...args: Parameters<EnvBucketsResource["listEnvBuckets"]>) => Promise<import("./env-buckets.js").EnvBucket[]>;
+export declare const getEnvBucket: (...args: Parameters<EnvBucketsResource["getEnvBucket"]>) => Promise<import("./env-buckets.js").EnvBucket>;
+export declare const setEnvBucket: (...args: Parameters<EnvBucketsResource["setEnvBucket"]>) => Promise<import("./env-buckets.js").EnvBucket>;
+export declare const deleteEnvBucket: (...args: Parameters<EnvBucketsResource["deleteEnvBucket"]>) => Promise<void>;
+export declare const getPlatformEnv: (...args: Parameters<EnvBucketsResource["getPlatformEnv"]>) => Promise<import("./env-buckets.js").PlatformEnvBucket>;
+export declare const getPlatformEnvReadonly: (...args: Parameters<EnvBucketsResource["getPlatformEnvReadonly"]>) => Promise<import("./env-buckets.js").PlatformEnvBucket>;
+export declare const setPlatformEnv: (...args: Parameters<EnvBucketsResource["setPlatformEnv"]>) => Promise<import("./env-buckets.js").PlatformEnvBucket>;
+export declare const deletePlatformEnv: (...args: Parameters<EnvBucketsResource["deletePlatformEnv"]>) => Promise<void>;

package/dist/react/api/gis-api.d.ts

@@ -0,0 +1,4 @@
+import type { GisResource } from "../../client/resources/gis.js";
+export type * from "../../client/resources/gis.js";
+export declare const fetchGisState: (...args: Parameters<GisResource["fetchGisState"]>) => Promise<import("../index.js").GisState>;
+export declare const fetchRuntimeConfig: (...args: Parameters<GisResource["fetchRuntimeConfig"]>) => Promise<import("../index.js").RuntimeConfig>;

package/dist/react/api/memories.d.ts

@@ -0,0 +1,14 @@
+import type { MemoriesResource } from "../../client/resources/memories.js";
+export type * from "../../client/resources/memories.js";
+export declare const createMemory: (...args: Parameters<MemoriesResource["createMemory"]>) => Promise<import("./memories.js").Memory>;
+export declare const listMemories: (...args: Parameters<MemoriesResource["listMemories"]>) => Promise<import("./memories.js").MemoryListResponse>;
+export declare const getMemory: (...args: Parameters<MemoriesResource["getMemory"]>) => Promise<import("./memories.js").Memory>;
+export declare const updateMemory: (...args: Parameters<MemoriesResource["updateMemory"]>) => Promise<import("./memories.js").Memory>;
+export declare const patchMemory: (...args: Parameters<MemoriesResource["patchMemory"]>) => Promise<import("./memories.js").Memory>;
+export declare const deleteMemory: (...args: Parameters<MemoriesResource["deleteMemory"]>) => Promise<{
+    ok: boolean;
+}>;
+export declare const batchMemories: (...args: Parameters<MemoriesResource["batchMemories"]>) => Promise<{
+    ok: boolean;
+    count: number;
+}>;

package/dist/react/api/model-config.d.ts

@@ -0,0 +1,68 @@
+export type ThinkingRequestFormat = "auto" | "none" | "openai_reasoning_effort" | "openrouter_reasoning" | "deepseek_thinking" | "together_reasoning" | "zai_thinking" | "qwen_enable_thinking" | "sglang_chat_template";
+export interface RuntimeProviderConfig {
+    name: string;
+    base_url: string;
+    api_key_configured: boolean;
+    thinking_request_format: ThinkingRequestFormat;
+    effective_thinking_request_format: Exclude<ThinkingRequestFormat, "auto">;
+}
+export interface RuntimeModelDetails {
+    id: string;
+    context_window: number;
+    supports_vision: boolean;
+}
+export interface RuntimeModelConfig {
+    id: string;
+    provider: RuntimeProviderConfig;
+    model: RuntimeModelDetails;
+}
+export interface RuntimeModelConfigCollection {
+    items: RuntimeModelConfig[];
+    default_config_id: string;
+    source: "saved" | "startup";
+}
+export interface UpdateProviderConfig {
+    base_url: string;
+    api_key?: string;
+    thinking_request_format: ThinkingRequestFormat;
+}
+export interface UpdateModelDetails {
+    id: string;
+    context_window: number;
+    supports_vision: boolean;
+}
+export interface UpdateRuntimeModelConfig {
+    provider: UpdateProviderConfig;
+    model: UpdateModelDetails;
+}
+export interface ModelConfigProbe {
+    provider: UpdateProviderConfig;
+    model_id: string;
+    config_id?: string;
+}
+export interface ModelCandidatesRequest {
+    provider: UpdateProviderConfig;
+    config_id?: string;
+}
+export interface ModelCandidatesResult {
+    provider_name: string;
+    models: string[];
+}
+export interface ContextWindowDetectionResult {
+    provider_name: string;
+    model_id: string;
+    context_window: number;
+}
+export interface ModelConfigTestResult {
+    ok: boolean;
+    provider_name: string;
+    model_id: string;
+}
+export declare function getRuntimeModelConfigs(): Promise<RuntimeModelConfigCollection>;
+export declare function createRuntimeModelConfig(config: UpdateRuntimeModelConfig): Promise<RuntimeModelConfigCollection>;
+export declare function updateRuntimeModelConfig(configId: string, config: UpdateRuntimeModelConfig): Promise<RuntimeModelConfigCollection>;
+export declare function deleteRuntimeModelConfig(configId: string): Promise<RuntimeModelConfigCollection>;
+export declare function setDefaultRuntimeModelConfig(configId: string): Promise<RuntimeModelConfigCollection>;
+export declare function detectContextWindow(config: ModelConfigProbe): Promise<ContextWindowDetectionResult>;
+export declare function listModelCandidates(config: ModelCandidatesRequest): Promise<ModelCandidatesResult>;
+export declare function testRuntimeModelConfig(config: ModelConfigProbe): Promise<ModelConfigTestResult>;

package/dist/react/api/models.d.ts

@@ -0,0 +1,13 @@
+import type { ModelsResource } from "../../client/resources/models.js";
+export * from "../../client/resources/models.js";
+export declare const getModelsConfig: (...args: Parameters<ModelsResource["getModelsConfig"]>) => Promise<{
+    default: string;
+    thinkingAvailable?: boolean | undefined;
+    models: {
+        id: string;
+        label: string;
+        inputModalities?: string[] | undefined;
+        supportsImage?: boolean | undefined;
+        thinkingAvailable?: boolean | undefined;
+    }[];
+}>;

package/dist/react/api/partner-skill.d.ts

@@ -0,0 +1,2 @@
+export { installPartnerSkill, uploadSessionSkill } from "./skills.js";
+export type { PartnerSkillInstallPayload, PartnerSkillInstallResult, SessionSkillUploadPayload, SessionSkillUploadResult, } from "../schemas/partner-skill.js";