@blade-hq/agent-kit 1.0.24 → 1.0.27

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,503 @@
+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" | "projection");
+    type AfterSequence = number;
+    interface SessionSubscribePayload {
+        session_id: SessionId;
+        mode?: Mode;
+        event_format?: EventFormat;
+        after_sequence?: AfterSequence;
+        [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" | "projection");
+    type AfterSequence = number;
+    interface SessionSubscribeBatchPayload {
+        sessions: Sessions;
+        [k: string]: unknown;
+    }
+    interface SessionSubscribe {
+        session_id: SessionId;
+        mode?: Mode;
+        event_format?: EventFormat;
+        after_sequence?: AfterSequence;
+        [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 TurnProjectionPayloadSchema {
+    type Id = string;
+    type Sequence = number;
+    type TurnId = string;
+    type LoopId = string;
+    type TurnKind = ("message" | "compaction");
+    type Role = ("user" | "assistant" | "system");
+    type Status = ("streaming" | "completed" | "paused" | "failed" | "interrupted");
+    type Type = ("text" | "thinking" | "tool_use" | "tool_result" | "tool_ui" | "tool_bridge" | "system_notification" | "mode_change" | "plan_status" | "ask_user_answer");
+    type Content = string;
+    type ToolCallId = (string | null);
+    type ToolName = (string | null);
+    type DisplayName = (string | null);
+    type Blocks = ContentBlock[];
+    type Id1 = string;
+    type ToolName1 = string;
+    type DisplayName1 = string;
+    type Arguments = string;
+    type Status1 = ("pending" | "done" | "error" | "cancelled" | "awaiting_answer");
+    type DurationMs = (number | null);
+    type ChildLoopName = string;
+    type ChildToolCallId = string;
+    type Description = (string | null);
+    type ToolCalls = ToolCallProjection[];
+    type Model = (string | null);
+    type Usage = ({
+        [k: string]: unknown;
+    } | null);
+    type DurationMs1 = number;
+    type StartedAt = (string | null);
+    type ContextWindow = number;
+    type MemoryRefs = (MemoryRef[] | null);
+    type Id2 = number;
+    type ContentPreview = string;
+    type SkillName = (string | null);
+    type ParentForkToolCallId = (string | null);
+    type CompactionId = (string | null);
+    type SummaryPreview = (string | null);
+    type SummaryFull = (string | null);
+    type ArchivedCount = (number | null);
+    type TokensBefore = (number | null);
+    type TokensAfter = (number | null);
+    type SavedRatio = (number | null);
+    type Trigger = (("auto" | "manual" | "forced_retry") | null);
+    type FailureReason = (string | null);
+    type FallbackApplied = (boolean | null);
+    type SessionId = string;
+    type SolutionId = (string | null);
+    type TemplateId = (string | null);
+    interface TurnProjectionPayload {
+        id: Id;
+        sequence: Sequence;
+        turn_id: TurnId;
+        loop_id: LoopId;
+        kind?: TurnKind;
+        role: Role;
+        status: Status;
+        blocks?: Blocks;
+        tool_calls?: ToolCalls;
+        model?: Model;
+        usage?: Usage;
+        duration_ms?: DurationMs1;
+        started_at?: StartedAt;
+        context_window?: ContextWindow;
+        memory_refs?: MemoryRefs;
+        parent_fork_tool_call_id?: ParentForkToolCallId;
+        compaction_id?: CompactionId;
+        summary_preview?: SummaryPreview;
+        summary_full?: SummaryFull;
+        archived_count?: ArchivedCount;
+        tokens_before?: TokensBefore;
+        tokens_after?: TokensAfter;
+        saved_ratio?: SavedRatio;
+        trigger?: Trigger;
+        failure_reason?: FailureReason;
+        fallback_applied?: FallbackApplied;
+        session_id: SessionId;
+        solution_id?: SolutionId;
+        template_id?: TemplateId;
+        [k: string]: unknown;
+    }
+    interface ContentBlock {
+        type: Type;
+        content?: Content;
+        tool_call_id?: ToolCallId;
+        tool_name?: ToolName;
+        display_name?: DisplayName;
+        [k: string]: unknown;
+    }
+    interface ToolCallProjection {
+        id: Id1;
+        tool_name: ToolName1;
+        display_name: DisplayName1;
+        arguments?: Arguments;
+        status?: Status1;
+        result?: Result;
+        duration_ms?: DurationMs;
+        pending_question_ref?: (PendingQuestionRef | null);
+        [k: string]: unknown;
+    }
+    interface Result {
+        [k: string]: unknown;
+    }
+    interface PendingQuestionRef {
+        child_loop_name: ChildLoopName;
+        child_tool_call_id: ChildToolCallId;
+        description?: Description;
+        [k: string]: unknown;
+    }
+    interface MemoryRef {
+        id: Id2;
+        content_preview: ContentPreview;
+        skill_name?: SkillName;
+        [k: string]: unknown;
+    }
+}
+export type TurnProjectionPayload = TurnProjectionPayloadSchema.TurnProjectionPayload;
+export declare namespace PatchEnvelopePayloadSchema {
+    type Sequence = number;
+    type TurnId = string;
+    type LoopId = string;
+    type PatchType = string;
+    type SessionId = string;
+    interface PatchEnvelopePayload {
+        sequence: Sequence;
+        turn_id: TurnId;
+        loop_id: LoopId;
+        patch_type: PatchType;
+        data?: Data;
+        session_id: SessionId;
+        [k: string]: unknown;
+    }
+    interface Data {
+        [k: string]: unknown;
+    }
+}
+export type PatchEnvelopePayload = PatchEnvelopePayloadSchema.PatchEnvelopePayload;
+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:start": (payload: TurnProjectionPayload) => void;
+    "turn:patch": (payload: PatchEnvelopePayload) => void;
+    "turn:end": (payload: TurnProjectionPayload) => 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/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/models.d.ts

@@ -0,0 +1,11 @@
+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;
+    models: {
+        id: string;
+        label: string;
+        inputModalities?: string[] | undefined;
+        supportsImage?: 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";