@tai42/studio-sdk 0.2.0

package/dist/hooks/useApi.d.ts

@@ -0,0 +1,1222 @@
+import type { ApiClient } from '@tai42/api-client';
+export declare const ApiProvider: import("react").Provider<{
+    readonly baseUrl: string;
+    readonly listTools: (signal?: AbortSignal) => Promise<string[]>;
+    readonly getToolSchema: (name: string, signal?: AbortSignal) => Promise<{
+        description: string | null;
+        input: Record<string, unknown>;
+        output: Record<string, unknown> | null;
+    }>;
+    readonly getAllToolSchemas: (signal?: AbortSignal) => Promise<Record<string, {
+        description: string | null;
+        input: Record<string, unknown>;
+        output: Record<string, unknown> | null;
+    }>>;
+    readonly runTool: (args: import("@tai42/api-client").RunToolArgs, signal?: AbortSignal) => Promise<unknown>;
+    readonly submitToolRun: (args: import("@tai42/api-client").SubmitToolRunArgs, signal?: AbortSignal) => Promise<{
+        run_id: string;
+    }>;
+    readonly getToolRun: (runId: string, signal?: AbortSignal) => Promise<{
+        tool_name: string;
+        status: "running" | "succeeded" | "failed" | "lost";
+        run_id: string;
+        started_at: string;
+        error?: string | undefined;
+        result?: unknown;
+        finished_at?: string | undefined;
+    }>;
+    readonly listToolRuns: (toolName: string, signal?: AbortSignal) => Promise<{
+        tool_name: string;
+        status: "running" | "succeeded" | "failed" | "lost";
+        run_id: string;
+        started_at: string;
+        finished_at?: string | undefined;
+    }[]>;
+    readonly listToolTags: (signal?: AbortSignal) => Promise<{
+        name: string;
+        tags: string[];
+    }[]>;
+    readonly listPresets: (signal?: AbortSignal) => Promise<{
+        name: string;
+        description: string;
+        tags: string[];
+        base_tool: string;
+        active_version: number;
+        extensions: (string | {
+            name: string;
+            config: Record<string, unknown>;
+        })[][];
+        output_schema: Record<string, unknown> | null;
+        conflicted: boolean;
+        conflicted_reason: string | null;
+    }[]>;
+    readonly createPreset: (body: import("@tai42/api-client").CreatePresetBody) => Promise<{
+        name: string;
+        description: string;
+        tags: string[];
+        base_tool: string;
+        active_version: number;
+        extensions: (string | {
+            name: string;
+            config: Record<string, unknown>;
+        })[][];
+        output_schema: Record<string, unknown> | null;
+        conflicted: boolean;
+        conflicted_reason: string | null;
+    }>;
+    readonly getPreset: (name: string, signal?: AbortSignal) => Promise<{
+        name: string;
+        description: string;
+        tags: string[];
+        base_tool: string;
+        active_version: number;
+        extensions: (string | {
+            name: string;
+            config: Record<string, unknown>;
+        })[][];
+        output_schema: Record<string, unknown> | null;
+        conflicted: boolean;
+        conflicted_reason: string | null;
+        fixed_kwargs: Record<string, unknown>;
+    }>;
+    readonly listPresetVersions: (name: string, signal?: AbortSignal) => Promise<{
+        tags: string[];
+        version: number;
+        body: {
+            description: string;
+            tags: string[];
+            base_tool: string;
+            extensions: (string | {
+                name: string;
+                config: Record<string, unknown>;
+            })[][];
+            output_schema: Record<string, unknown> | null;
+            fixed_kwargs: Record<string, unknown>;
+        };
+        created_at: string;
+        is_current: boolean;
+    }[]>;
+    readonly getPresetVersion: (name: string, version: number, signal?: AbortSignal) => Promise<{
+        tags: string[];
+        version: number;
+        body: {
+            description: string;
+            tags: string[];
+            base_tool: string;
+            extensions: (string | {
+                name: string;
+                config: Record<string, unknown>;
+            })[][];
+            output_schema: Record<string, unknown> | null;
+            fixed_kwargs: Record<string, unknown>;
+        };
+        created_at: string;
+        is_current: boolean;
+    }>;
+    readonly savePresetVersion: (name: string, body: import("@tai42/api-client").SavePresetVersionBody) => Promise<{
+        tags: string[];
+        version: number;
+        body: {
+            description: string;
+            tags: string[];
+            base_tool: string;
+            extensions: (string | {
+                name: string;
+                config: Record<string, unknown>;
+            })[][];
+            output_schema: Record<string, unknown> | null;
+            fixed_kwargs: Record<string, unknown>;
+        };
+        created_at: string;
+        is_current: boolean;
+    }>;
+    readonly rollbackPreset: (name: string, version: number) => Promise<{
+        name: string;
+        active_version: number;
+    }>;
+    readonly deletePreset: (name: string) => Promise<{
+        name: string;
+        deleted: true;
+    }>;
+    readonly renamePreset: (name: string, newName: string) => Promise<{
+        name: string;
+        active_version: number;
+        renamed_from: string;
+    }>;
+    readonly getPresetReferees: (name: string, signal?: AbortSignal) => Promise<{
+        name: string;
+        referees: string[];
+    }>;
+    readonly validatePreset: (body: import("@tai42/api-client").ValidatePresetBody) => Promise<{
+        error: string | null;
+        valid: boolean;
+    }>;
+    readonly setPresetVersionTags: (name: string, version: number, tags: readonly string[]) => Promise<{
+        name: string;
+        tags: string[];
+        version: number;
+    }>;
+    readonly getStorageInfo: (signal?: AbortSignal) => Promise<{
+        present: boolean;
+        provider: string | null;
+        module: string | null;
+    }>;
+    readonly listStorageResources: (signal?: AbortSignal) => Promise<{
+        resources: string[];
+    }>;
+    readonly statStorageResource: (id: string, signal?: AbortSignal) => Promise<{
+        id: string;
+        content_type: string | null;
+    }>;
+    readonly downloadStorageResource: (id: string, signal?: AbortSignal) => Promise<Blob>;
+    readonly uploadStorageResource: (body: import("@tai42/api-client").StorageUploadBody) => Promise<{
+        id: string;
+        stored: true;
+    }>;
+    readonly deleteStorageResource: (id: string) => Promise<{
+        deleted: true;
+        id: string;
+    }>;
+    readonly deleteStorageDir: (path: string) => Promise<{
+        deleted: true;
+        dir: string;
+    }>;
+    readonly getBackendInfo: (signal?: AbortSignal) => Promise<{
+        present: boolean;
+        module: string | null;
+        backend: string | null;
+    }>;
+    readonly listFleetWorkers: (signal?: AbortSignal) => Promise<{
+        workers: {
+            kind: "backend" | "serve";
+            origin: string;
+            pid: number;
+        }[];
+    }>;
+    readonly reloadFleetConfig: (targets: string[] | null) => Promise<{
+        error: string | null;
+        op: string;
+        reachable: boolean;
+        local_only: boolean;
+        results: {
+            error: string | null;
+            origin: string;
+            outcome: "failed" | "applied" | "missing" | "departed" | "timed_out";
+            detail: string | null;
+            payload?: unknown;
+        }[];
+    }>;
+    readonly listExtensions: (signal?: AbortSignal) => Promise<{
+        name: string;
+        kind: string;
+    }[]>;
+    readonly getToolExtensions: (name: string, signal?: AbortSignal) => Promise<{
+        combos: (string | {
+            name: string;
+            config: Record<string, unknown>;
+        })[][];
+        available: {
+            name: string;
+            kind: string;
+        }[];
+    }>;
+    readonly setToolExtensions: (name: string, combos: readonly import("@tai42/api-client").PresetExtensionElement[][]) => Promise<{
+        status: string;
+        env_keys: number;
+        fanout: {
+            mode: "local-only";
+            note: string;
+        } | {
+            error: string | null;
+            op: string;
+            reachable: boolean;
+            local_only: boolean;
+            results: {
+                error: string | null;
+                origin: string;
+                outcome: "failed" | "applied" | "missing" | "departed" | "timed_out";
+                detail: string | null;
+                payload?: unknown;
+            }[];
+            mode: "fleet";
+        } | {
+            error: string | null;
+            op: string;
+            reachable: boolean;
+            local_only: boolean;
+            results: {
+                error: string | null;
+                origin: string;
+                outcome: "failed" | "applied" | "missing" | "departed" | "timed_out";
+                detail: string | null;
+                payload?: unknown;
+            }[];
+            mode: "unreachable";
+        };
+    }>;
+    readonly listTemplates: (signal?: AbortSignal) => Promise<string[]>;
+    readonly getTemplate: (templateId: string) => Promise<{
+        template: string;
+        schema: Record<string, unknown>;
+    }>;
+    readonly uploadTemplate: (path: string, content: string) => Promise<{
+        path: string;
+        uploaded: true;
+    }>;
+    readonly deleteTemplate: (path: string) => Promise<{
+        path: string;
+        deleted: true;
+    }>;
+    readonly renderTemplate: (body: {
+        content?: string;
+        template_id?: string;
+        kwargs?: Record<string, unknown>;
+    }) => Promise<{
+        rendered: string;
+    }>;
+    readonly clearTemplatesCache: () => Promise<{
+        cleared: true;
+    }>;
+    readonly getManifest: (signal?: AbortSignal) => Promise<{
+        mcp: Record<string, unknown>[];
+        user_tools: string[];
+    }>;
+    readonly setMcpConfig: (mcp: unknown[]) => Promise<{
+        status: string;
+        env_keys: number;
+        fanout: {
+            mode: "local-only";
+            note: string;
+        } | {
+            error: string | null;
+            op: string;
+            reachable: boolean;
+            local_only: boolean;
+            results: {
+                error: string | null;
+                origin: string;
+                outcome: "failed" | "applied" | "missing" | "departed" | "timed_out";
+                detail: string | null;
+                payload?: unknown;
+            }[];
+            mode: "fleet";
+        } | {
+            error: string | null;
+            op: string;
+            reachable: boolean;
+            local_only: boolean;
+            results: {
+                error: string | null;
+                origin: string;
+                outcome: "failed" | "applied" | "missing" | "departed" | "timed_out";
+                detail: string | null;
+                payload?: unknown;
+            }[];
+            mode: "unreachable";
+        };
+    }>;
+    readonly getMcpStatus: (signal?: AbortSignal) => Promise<{
+        failed: {
+            status: string;
+            title: string;
+        }[];
+        bound: Record<string, string[]>;
+    }>;
+    readonly reloadMcp: (title: string) => Promise<{
+        error: string | null;
+        op: string;
+        reachable: boolean;
+        local_only: boolean;
+        results: {
+            error: string | null;
+            origin: string;
+            outcome: "failed" | "applied" | "missing" | "departed" | "timed_out";
+            detail: string | null;
+            payload?: unknown;
+        }[];
+    }>;
+    readonly listSubMcp: (signal?: AbortSignal) => Promise<Record<string, Record<string, unknown>>>;
+    readonly createSubMcp: (slug: string, tools: string[]) => Promise<{
+        slug: string;
+        tools: string[];
+    }>;
+    readonly deleteSubMcp: (slug: string) => Promise<{
+        slug: string;
+        removed: true;
+    }>;
+    readonly getEnvConfig: (signal?: AbortSignal) => Promise<{
+        env: Record<string, string>;
+        secret_keys: string[];
+    }>;
+    readonly setEnvConfig: (env: Record<string, string>) => Promise<{
+        status: string;
+        env_keys: number;
+        fanout: {
+            mode: "local-only";
+            note: string;
+        } | {
+            error: string | null;
+            op: string;
+            reachable: boolean;
+            local_only: boolean;
+            results: {
+                error: string | null;
+                origin: string;
+                outcome: "failed" | "applied" | "missing" | "departed" | "timed_out";
+                detail: string | null;
+                payload?: unknown;
+            }[];
+            mode: "fleet";
+        } | {
+            error: string | null;
+            op: string;
+            reachable: boolean;
+            local_only: boolean;
+            results: {
+                error: string | null;
+                origin: string;
+                outcome: "failed" | "applied" | "missing" | "departed" | "timed_out";
+                detail: string | null;
+                payload?: unknown;
+            }[];
+            mode: "unreachable";
+        };
+    }>;
+    readonly getConfigMode: (signal?: AbortSignal) => Promise<{
+        config_mode: string;
+        read_only: boolean;
+    }>;
+    readonly listProviders: (signal?: AbortSignal) => Promise<{
+        description: string;
+        kind: "oauth" | "none";
+        id: string;
+        origin: "system" | "community";
+        display_name: string;
+        icon_url: string;
+        category: string;
+        sub_services: {
+            description: string;
+            id: string;
+            display_name: string;
+            scopes: string[];
+        }[];
+        config_fields: {
+            key: string;
+            required: boolean;
+            label: string;
+            target: "env" | "header";
+            secret: boolean;
+        }[];
+    }[]>;
+    readonly listConnections: (signal?: AbortSignal) => Promise<{
+        items: {
+            kind: "oauth" | "none";
+            created_at: string;
+            connection_id: string;
+            provider_id: string;
+            alias: string;
+            account_identity: string | null;
+            enabled_sub_services: string[];
+            granted_scopes: string[];
+            auth_health_state: "healthy" | "reconnect_required" | "refresh_failing";
+        }[];
+        total: number;
+    }>;
+    readonly getConnection: (id: string, signal?: AbortSignal) => Promise<{
+        kind: "oauth" | "none";
+        created_at: string;
+        connection_id: string;
+        provider_id: string;
+        alias: string;
+        account_identity: string | null;
+        enabled_sub_services: string[];
+        granted_scopes: string[];
+        auth_health_state: "healthy" | "reconnect_required" | "refresh_failing";
+    }>;
+    readonly startConnect: (args: import("@tai42/api-client").StartConnectArgs) => Promise<{
+        flow_id: string;
+        authorize_url: string;
+    } | {
+        fanout: {
+            mode: "local-only";
+            note: string;
+        } | {
+            error: string | null;
+            op: string;
+            reachable: boolean;
+            local_only: boolean;
+            results: {
+                error: string | null;
+                origin: string;
+                outcome: "failed" | "applied" | "missing" | "departed" | "timed_out";
+                detail: string | null;
+                payload?: unknown;
+            }[];
+            mode: "fleet";
+        } | {
+            error: string | null;
+            op: string;
+            reachable: boolean;
+            local_only: boolean;
+            results: {
+                error: string | null;
+                origin: string;
+                outcome: "failed" | "applied" | "missing" | "departed" | "timed_out";
+                detail: string | null;
+                payload?: unknown;
+            }[];
+            mode: "unreachable";
+        } | null;
+        connection_id: string;
+        added_manifest_entries: string[];
+    }>;
+    readonly disconnect: (id: string) => Promise<{
+        fanout: {
+            mode: "local-only";
+            note: string;
+        } | {
+            error: string | null;
+            op: string;
+            reachable: boolean;
+            local_only: boolean;
+            results: {
+                error: string | null;
+                origin: string;
+                outcome: "failed" | "applied" | "missing" | "departed" | "timed_out";
+                detail: string | null;
+                payload?: unknown;
+            }[];
+            mode: "fleet";
+        } | {
+            error: string | null;
+            op: string;
+            reachable: boolean;
+            local_only: boolean;
+            results: {
+                error: string | null;
+                origin: string;
+                outcome: "failed" | "applied" | "missing" | "departed" | "timed_out";
+                detail: string | null;
+                payload?: unknown;
+            }[];
+            mode: "unreachable";
+        } | null;
+        connection_id: string;
+        upstream_revoke_outcome: "failed" | "success" | "skipped";
+        upstream_revoke_status: number | null;
+        removed_manifest_entries: string[];
+    }>;
+    readonly reconnect: (id: string, enabled_sub_services: string[], return_url?: string) => Promise<{
+        flow_id: string;
+        authorize_url: string;
+    }>;
+    readonly patchSubServices: (id: string, enabled_sub_services: string[], return_url?: string) => Promise<{
+        fanout: {
+            mode: "local-only";
+            note: string;
+        } | {
+            error: string | null;
+            op: string;
+            reachable: boolean;
+            local_only: boolean;
+            results: {
+                error: string | null;
+                origin: string;
+                outcome: "failed" | "applied" | "missing" | "departed" | "timed_out";
+                detail: string | null;
+                payload?: unknown;
+            }[];
+            mode: "fleet";
+        } | {
+            error: string | null;
+            op: string;
+            reachable: boolean;
+            local_only: boolean;
+            results: {
+                error: string | null;
+                origin: string;
+                outcome: "failed" | "applied" | "missing" | "departed" | "timed_out";
+                detail: string | null;
+                payload?: unknown;
+            }[];
+            mode: "unreachable";
+        } | null;
+        connection_id: string;
+        enabled_sub_services: string[];
+        flow_id: string | null;
+        authorize_url: string | null;
+        added_manifest_entries: string[];
+        removed_manifest_entries: string[];
+        consent_required: boolean;
+    }>;
+    readonly completeOAuth: (state: string, code: string, error?: string) => Promise<{
+        kind: "success";
+        fanout: {
+            mode: "local-only";
+            note: string;
+        } | {
+            error: string | null;
+            op: string;
+            reachable: boolean;
+            local_only: boolean;
+            results: {
+                error: string | null;
+                origin: string;
+                outcome: "failed" | "applied" | "missing" | "departed" | "timed_out";
+                detail: string | null;
+                payload?: unknown;
+            }[];
+            mode: "fleet";
+        } | {
+            error: string | null;
+            op: string;
+            reachable: boolean;
+            local_only: boolean;
+            results: {
+                error: string | null;
+                origin: string;
+                outcome: "failed" | "applied" | "missing" | "departed" | "timed_out";
+                detail: string | null;
+                payload?: unknown;
+            }[];
+            mode: "unreachable";
+        } | null;
+        connection_id: string;
+        return_url: string;
+    } | {
+        reason: string;
+        kind: "failed";
+    } | {
+        message: string;
+        kind: "cancelled";
+    }>;
+    readonly listStudioPlugins: (signal?: AbortSignal) => Promise<{
+        name: string;
+        version: string;
+        api_version: number;
+        entry: string;
+        integrity: Record<string, string>;
+        contributions: {
+            tool_panels: Record<string, string>;
+            pages: string[];
+            settings_tabs: string[];
+            nav_entries: string[];
+        };
+    }[]>;
+    readonly answerInteraction: (interactionId: string, answer: unknown) => Promise<{
+        status: string;
+        interaction_id: string;
+    }>;
+    readonly listChannels: (signal?: AbortSignal) => Promise<{
+        channels: string[];
+    }>;
+    readonly listNotifications: (signal?: AbortSignal) => Promise<{
+        notifications: {
+            message: string;
+            created_at: string;
+            id: string;
+            recipient: string | null;
+        }[];
+    }>;
+    readonly listAgents: (signal?: AbortSignal) => Promise<{
+        items: {
+            name: string;
+            description: string;
+            tool_name: string;
+            input_schema: Record<string, unknown>;
+            spec_runnable: boolean;
+        }[];
+        total: number;
+    }>;
+    readonly listSpecRunnableAgents: (signal?: AbortSignal) => Promise<{
+        items: {
+            name: string;
+            description: string;
+            tool_name: string;
+            input_schema: Record<string, unknown>;
+            spec_runnable: boolean;
+        }[];
+        total: number;
+    }>;
+    readonly streamAgentRun: (name: string, input: unknown, signal?: AbortSignal) => Promise<AsyncGenerator<import("@tai42/api-client").ParsedAgentEvent, any, any>>;
+    readonly streamAuthoredAgentRun: (name: string, input: unknown, signal?: AbortSignal) => Promise<AsyncGenerator<import("@tai42/api-client").ParsedAgentEvent, any, any>>;
+    readonly listHooks: (topic?: string, signal?: AbortSignal) => Promise<{
+        items: {
+            name: string;
+            tool: string;
+            topic: string;
+            execution_key: string;
+            tool_kwargs: Record<string, unknown>;
+            condition: string | null;
+            condition_id: string | null;
+            condition_kwargs: Record<string, unknown>;
+            expr: string | null;
+            expr_id: string | null;
+            expr_kwargs: Record<string, unknown>;
+        }[];
+        total: number;
+        topic_verifiers: Record<string, {
+            config: Record<string, unknown>;
+            verifier: string;
+        }>;
+        trigger_auth: Record<string, "public" | "verifier" | "token" | "token+api_key" | "out-of-service">;
+    }>;
+    readonly registerHook: (params: import("@tai42/api-client").HookParams) => Promise<{
+        name: string;
+        registered: boolean;
+    }>;
+    readonly unregisterHook: (name: string) => Promise<{
+        name: string;
+        removed: boolean;
+    }>;
+    readonly listHookVerifiers: (signal?: AbortSignal) => Promise<string[]>;
+    readonly setTopicVerifier: (topic: string, body: import("@tai42/api-client").TopicVerifierBody) => Promise<{
+        verifier: string;
+        topic: string;
+    }>;
+    readonly deleteTopicVerifier: (topic: string) => Promise<{
+        removed: boolean;
+        topic: string;
+    }>;
+    readonly createTriggerLink: (body: import("@tai42/api-client").TriggerLinkCreateBody) => Promise<{
+        name: string;
+        token: string;
+        topic: string;
+        trigger_path: string;
+        expires_at: string | null;
+    }>;
+    readonly listTriggerLinks: (signal?: AbortSignal) => Promise<{
+        items: {
+            name: string;
+            created_at: string;
+            topic: string;
+            execution_key: string;
+            tool_kwargs: Record<string, unknown> | null;
+            trigger_auth: "public" | "verifier" | "token" | "token+api_key" | "out-of-service";
+            expires_at: string | null;
+            created_by: string | null;
+            token_hash_prefix: string;
+        }[];
+        total: number;
+    }>;
+    readonly deleteTriggerLink: (name: string) => Promise<{
+        name: string;
+        removed: boolean;
+    }>;
+    readonly getMcpConfigSchema: (signal?: AbortSignal) => Promise<Record<string, unknown>>;
+    readonly getSettingsSchema: (signal?: AbortSignal) => Promise<{
+        groups: {
+            name: string;
+            module: string;
+            qualname: string;
+            fields: {
+                name: string;
+                description: string | null;
+                type: string;
+                required: boolean;
+                secret: boolean;
+                env_var: string;
+                nested_group: string | null;
+                value?: unknown;
+                default?: unknown;
+            }[];
+        }[];
+    }>;
+    readonly listScopes: (signal?: AbortSignal) => Promise<Record<string, string>>;
+    readonly addUrlToScope: (body: import("@tai42/api-client").AddUrlToScopeBody) => Promise<{
+        url: string;
+        scope_id: string;
+    }>;
+    readonly removeUrlFromScope: (body: {
+        url: string;
+    }) => Promise<{
+        url: string;
+    }>;
+    readonly removeScope: (scopeId: string) => Promise<{
+        scope_id: string;
+        deleted_keys: number;
+    }>;
+    readonly listAuthRoutes: (signal?: AbortSignal) => Promise<{
+        path: string;
+        tags: string[];
+        methods: string[];
+        mapped: string | null;
+        summary: string;
+        action: "secret" | "read" | "write" | "fenced" | null;
+    }[]>;
+    readonly listPublicRoutes: (signal?: AbortSignal) => Promise<string[]>;
+    readonly pinRoutePublic: (body: import("@tai42/api-client").PinRoutePublicBody) => Promise<{
+        url: string;
+    }>;
+    readonly unpinPublicRoute: (url: string) => Promise<{
+        url: string;
+    }>;
+    readonly listRoles: (signal?: AbortSignal) => Promise<{
+        name: string;
+        description: string;
+        scopes: string[];
+        condition: string | null;
+        condition_id: string | null;
+        base_tier: string | null;
+        allow_all: boolean;
+        grants: Record<string, "none" | "read" | "write">;
+        condition_kwargs?: unknown;
+    }[]>;
+    readonly createRole: (body: import("@tai42/api-client").RoleCreateBody) => Promise<{
+        name: string;
+        description: string;
+        scopes: string[];
+        condition: string | null;
+        condition_id: string | null;
+        base_tier: string | null;
+        allow_all: boolean;
+        grants: Record<string, "none" | "read" | "write">;
+        condition_kwargs?: unknown;
+    }>;
+    readonly updateRole: (name: string, body: import("@tai42/api-client").RoleUpdateBody) => Promise<{
+        name: string;
+        description: string;
+        scopes: string[];
+        condition: string | null;
+        condition_id: string | null;
+        base_tier: string | null;
+        allow_all: boolean;
+        grants: Record<string, "none" | "read" | "write">;
+        condition_kwargs?: unknown;
+    }>;
+    readonly deleteRole: (name: string) => Promise<{
+        name: string;
+        deleted: boolean;
+    }>;
+    readonly listRoleVersions: (name: string, signal?: AbortSignal) => Promise<{
+        versions: {
+            tags: string[];
+            version: number;
+            body: {
+                name: string;
+                description: string;
+                scopes: string[];
+                condition: string | null;
+                condition_id: string | null;
+                base_tier: string | null;
+                allow_all: boolean;
+                grants: Record<string, "none" | "read" | "write">;
+                condition_kwargs?: unknown;
+            };
+            created_at: string;
+            is_current: boolean;
+        }[];
+        audit: {
+            tags: string[];
+            version: number;
+            body: {
+                action: string;
+                actor: string | null;
+                before?: unknown;
+                after?: unknown;
+            };
+            created_at: string;
+            is_current: boolean;
+        }[];
+    }>;
+    readonly rollbackRole: (name: string, version: number) => Promise<{
+        name: string;
+        description: string;
+        scopes: string[];
+        condition: string | null;
+        condition_id: string | null;
+        base_tier: string | null;
+        allow_all: boolean;
+        grants: Record<string, "none" | "read" | "write">;
+        condition_kwargs?: unknown;
+    }>;
+    readonly listTokensPayload: (signal?: AbortSignal) => Promise<{
+        description: string;
+        scopes: string[];
+        user_id: string;
+        condition?: string | null | undefined;
+        condition_id?: string | null | undefined;
+        condition_kwargs?: unknown;
+        policy_data?: unknown;
+    }[]>;
+    readonly createApiKey: (body: import("@tai42/api-client").ApiKeyBody) => Promise<string>;
+    readonly editApiKey: (userId: string, body: Omit<import("@tai42/api-client").ApiKeyBody, "user_id">) => Promise<{
+        user_id: string;
+        updated: boolean;
+    }>;
+    readonly revokeApiKey: (userId: string) => Promise<{
+        user_id: string;
+        revoked: boolean;
+    }>;
+    readonly createClaimLink: (body: import("@tai42/api-client").ClaimLinkBody) => Promise<{
+        token: string;
+        expires_at: string;
+        claim_path: string;
+    }>;
+    readonly getMe: (signal?: AbortSignal) => Promise<{
+        tools: string[];
+        scopes: string[];
+        user_id: string;
+        owner_user_id: string | null;
+        admin: boolean;
+        routes: {
+            path: string;
+            methods: string[];
+        }[];
+        route_patterns: {
+            scope_id: string;
+            pattern: string;
+        }[];
+        sub_mcp: {
+            slug: string;
+            tools: string[];
+            transport: string;
+        }[];
+        agents: string[];
+        mintable: boolean;
+    }>;
+    readonly getLoginMethods: (options?: {
+        signal?: AbortSignal;
+    }) => Promise<{
+        methods: ({
+            shape: "form";
+            id: string;
+            title: string;
+            fields: {
+                name: string;
+                label: string;
+                secret: boolean;
+                autocomplete?: string | undefined;
+            }[];
+            purpose: "login" | "bootstrap" | "invite";
+            submit_path: string;
+        } | {
+            shape: "button";
+            id: string;
+            label: string;
+            href: string;
+            icon?: string | undefined;
+        })[];
+        bootstrap: boolean;
+    }>;
+    readonly submitLoginForm: (path: string, values: Record<string, string>) => Promise<{
+        token: string;
+        user_id: string;
+    }>;
+    readonly exchangeSsoCode: (code: string) => Promise<{
+        token: string;
+        user_id: string;
+    }>;
+    readonly claimLogin: (body: {
+        token: string;
+    }) => Promise<{
+        token: string;
+        user_id: string;
+    }>;
+    readonly getAuthCapabilities: (signal?: AbortSignal) => Promise<{
+        mintable: boolean;
+        providers: {
+            name: string;
+            mintable: boolean;
+        }[];
+    }>;
+    readonly logout: () => Promise<{
+        revoked: boolean;
+    }>;
+    readonly validateCondition: (body: import("@tai42/api-client").ValidateConditionBody) => Promise<{
+        result: boolean | null;
+        ok: boolean;
+    }>;
+    readonly listPolicyVersions: (userId: string, signal?: AbortSignal) => Promise<{
+        tags: string[];
+        version: number;
+        body: {
+            scopes: string[];
+            condition: string | null;
+            condition_id: string | null;
+            condition_kwargs?: unknown;
+            policy_data?: unknown;
+        };
+        created_at: string;
+        is_current: boolean;
+    }[]>;
+    readonly rollbackPolicy: (userId: string, version: number) => Promise<{
+        active_version: number;
+        user_id: string;
+    }>;
+    readonly listBackupSections: (signal?: AbortSignal) => Promise<{
+        name: string;
+        secret: boolean;
+    }[]>;
+    readonly exportBackup: (sections: string[], signal?: AbortSignal) => Promise<Blob>;
+    readonly importBackup: (body: {
+        document: unknown;
+        sections: string[];
+    }) => Promise<{
+        ok: boolean;
+        sections: Record<string, {
+            skipped: number;
+            updated: number;
+            errors: string[];
+            created: number;
+            fanout?: {
+                mode: "local-only";
+                note: string;
+            } | {
+                error: string | null;
+                op: string;
+                reachable: boolean;
+                local_only: boolean;
+                results: {
+                    error: string | null;
+                    origin: string;
+                    outcome: "failed" | "applied" | "missing" | "departed" | "timed_out";
+                    detail: string | null;
+                    payload?: unknown;
+                }[];
+                mode: "fleet";
+            } | {
+                error: string | null;
+                op: string;
+                reachable: boolean;
+                local_only: boolean;
+                results: {
+                    error: string | null;
+                    origin: string;
+                    outcome: "failed" | "applied" | "missing" | "departed" | "timed_out";
+                    detail: string | null;
+                    payload?: unknown;
+                }[];
+                mode: "unreachable";
+            } | undefined;
+            new_api_keys?: {
+                description: string;
+                user_id: string;
+                api_key: string;
+            }[] | undefined;
+        }>;
+    }>;
+    readonly listSchedules: (signal?: AbortSignal) => Promise<import("zod").objectOutputType<{
+        name: import("zod").ZodString;
+        enabled: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        schedule: import("zod").ZodOptional<import("zod").ZodType<unknown, import("zod").ZodTypeDef, unknown>>;
+        target: import("zod").ZodOptional<import("zod").ZodType<unknown, import("zod").ZodTypeDef, unknown>>;
+        args: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodType<unknown, import("zod").ZodTypeDef, unknown>, "many">>;
+        kwargs: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodType<unknown, import("zod").ZodTypeDef, unknown>>>;
+    }, import("zod").ZodTypeAny, "passthrough">[]>;
+    readonly getServerDateTime: (signal?: AbortSignal) => Promise<import("zod").objectOutputType<{
+        utc: import("zod").ZodType<unknown, import("zod").ZodTypeDef, unknown>;
+        local: import("zod").ZodOptional<import("zod").ZodType<unknown, import("zod").ZodTypeDef, unknown>>;
+        system: import("zod").ZodOptional<import("zod").ZodType<unknown, import("zod").ZodTypeDef, unknown>>;
+    }, import("zod").ZodTypeAny, "passthrough">>;
+    readonly addSchedule: (body: {
+        tool_name: string;
+        tool_kwargs: Record<string, unknown>;
+        schedule_kwargs: Record<string, unknown>;
+    }) => Promise<unknown>;
+    readonly deleteSchedule: (name: string) => Promise<unknown>;
+    readonly getObservabilityMetrics: (params?: import("@tai42/api-client").MetricsQuery, signal?: AbortSignal) => Promise<{
+        summary: {
+            totalRuns: number;
+            totalCost: number;
+            totalTokens: number;
+            averageLatencyMs: number;
+            avgCostPerRun: number;
+            avgTokensPerRun: number;
+            timeToFirstTokenMs: number | null;
+        };
+        timeSeries: {
+            totalTokens: number;
+            bucket: string | null;
+            runs: number;
+            cost: number;
+            avgLatencyMs: number;
+        }[];
+        byModel: {
+            model: string;
+            totalTokens: number;
+            cost: number;
+            avgLatencyMs: number;
+            calls: number;
+        }[];
+        granularity: "hour" | "day" | "week";
+    }>;
+    readonly listRuns: (params?: import("@tai42/api-client").RunsQuery, signal?: AbortSignal) => Promise<{
+        items: {
+            status: "error" | "success";
+            model: string | null;
+            tags: string[];
+            id: string;
+            totalTokens: number | null;
+            cost: number | null;
+            traceId: string;
+            createdAt: string | null;
+            latencyMs: number | null;
+            fetchError: string | null;
+            inputPreview?: unknown;
+            outputPreview?: unknown;
+        }[];
+        page: number;
+        nextPage: number | null;
+    }>;
+    readonly getRunTrace: (traceId: string, signal?: AbortSignal) => Promise<{
+        tags: string[];
+        totalCost: number | null;
+        traceId: string;
+        fetchError: string | null;
+        timestamp: string | null;
+        availability: "partial" | "unavailable" | "full";
+        spans: {
+            name: string | null;
+            type: string | null;
+            model: string | null;
+            id: string;
+            traceId: string | null;
+            parentId: string | null;
+            level: string | null;
+            statusMessage: string | null;
+            start: string | null;
+            end: string | null;
+            nodeId: string | null;
+            input?: unknown;
+            output?: unknown;
+            usage?: unknown;
+            metadata?: unknown;
+        }[];
+        input?: unknown;
+        output?: unknown;
+        metadata?: unknown;
+    }>;
+    readonly exportTrace: (traceId: string, signal?: AbortSignal) => Promise<Blob>;
+    readonly exportRuns: (params: import("@tai42/api-client").RunsQuery & {
+        format: "csv" | "json";
+    }, signal?: AbortSignal) => Promise<Blob>;
+    readonly searchMarketplace: (query?: import("@tai42/api-client").MarketplaceSearchQuery, signal?: AbortSignal) => Promise<{
+        items: {
+            name: string;
+            description: string;
+            tags: string[];
+            display_name: string | null;
+            icon_url: string | null;
+            item: {
+                name: string;
+                description: string;
+                tags: string[];
+                kind: string;
+            };
+            ref: string;
+            namespace: string;
+            package: string;
+            categories: string[];
+            trust_tier: string;
+            pricing: string;
+            latest_version: string | null;
+            downloads: number;
+            updated_at: string;
+        }[];
+        total: number;
+        page: number;
+        page_size: number;
+    }>;
+    readonly getMarketplacePlugin: (namespace: string, name: string, signal?: AbortSignal) => Promise<{
+        name: string;
+        description: string;
+        tags: string[];
+        display_name: string | null;
+        icon_url: string | null;
+        versions: {
+            status: string;
+            version: string;
+            contract_range: string | null;
+            published_at: string | null;
+        }[];
+        namespace: string;
+        package: string;
+        categories: string[];
+        trust_tier: string;
+        pricing: string;
+        downloads: number;
+        readme_md: string | null;
+        license: string | null;
+        homepage_url: string | null;
+        repository_url: string | null;
+        latest: {
+            status: string;
+            items: {
+                name: string;
+                description: string;
+                tags: string[];
+                kind: string;
+            }[];
+            version: string;
+            contract_range: string | null;
+            published_at: string | null;
+        } | null;
+    }>;
+    readonly listMarketplaceCategories: (signal?: AbortSignal) => Promise<string[]>;
+    readonly listInstalledMarketplacePlugins: (signal?: AbortSignal) => Promise<{
+        version: string;
+        ref: string;
+        latest: string | null;
+        source: string;
+        installed_at: string;
+        update_available: boolean;
+        missing_upstream: boolean;
+    }[]>;
+    readonly installMarketplacePlugin: (body: import("@tai42/api-client").MarketplaceInstallBody) => Promise<{
+        version: string;
+        ref: string;
+        advisories: {
+            created_at: string;
+            id: number;
+            summary: string;
+            listing: string;
+            affected_versions: string;
+            severity: string;
+            withdrawn_at: string | null;
+        }[];
+        notes: string[];
+    }>;
+    readonly uninstallMarketplacePlugin: (body: import("@tai42/api-client").MarketplaceUninstallBody) => Promise<{
+        ref: string;
+        notes: string[];
+        uninstalled: true;
+    }>;
+    readonly updateMarketplacePlugin: (body: import("@tai42/api-client").MarketplaceInstallBody) => Promise<{
+        version: string;
+        ref: string;
+        advisories: {
+            created_at: string;
+            id: number;
+            summary: string;
+            listing: string;
+            affected_versions: string;
+            severity: string;
+            withdrawn_at: string | null;
+        }[];
+        notes: string[];
+    }>;
+    readonly getMarketplaceAdvisories: (signal?: AbortSignal) => Promise<{
+        advisories: {
+            created_at: string;
+            id: number;
+            summary: string;
+            listing: string;
+            affected_versions: string;
+            severity: string;
+            withdrawn_at: string | null;
+        }[];
+        fetched_at: string;
+    }>;
+    readonly getHealth: (signal?: AbortSignal) => Promise<string>;
+    readonly getSystemKinds: (signal?: AbortSignal) => Promise<{
+        kind: string;
+        detail: string;
+        state: "active" | "default" | "off";
+        plugin: string | null;
+    }[]>;
+    readonly streamInteractions: (signal?: AbortSignal) => Promise<AsyncGenerator<import("@tai42/api-client").SseFrame, any, any>>;
+} | null>;
+export declare function useApi(): ApiClient;
+export type { ApiClient };
+//# sourceMappingURL=useApi.d.ts.map