qlogicagent 2.15.4 → 2.15.6

package/dist/types/protocol/wire/agent-methods.d.ts

@@ -11,6 +11,7 @@
 import type { ChatMessage, LocalizedToolText, ToolCapabilityCategory } from "./chat-types.js";
 import type { GatewayRpcMethodMap } from "./gateway-rpc.js";
 import type { WireTokenUsage } from "./notification-payloads.js";
+import type { SoloEvaluation, SoloMessageParams, SoloEvaluateParams, SoloDeleteParams, ProductPlan, ProductPlanParams, ProductConfirmParams, ProductMessageParams, ProductIdParams, ProductDeleteParams, AgentsGetGatewayResult, AgentsListConfiguredItem, AgentsProcessInfo, AgentsKillParams, AgentsGetLogParams, AgentsGetLogResult, AgentsTestConnectionParams, AgentsTestConnectionResult } from "./acp-agent-management.js";
 export type AgentCategory = "sub-agent" | "teammate";
 export type AgentProtocol = "internal" | "acp";
 export type AgentStatus = "available" | "unavailable" | "handshake_failed" | "not_installed";
@@ -561,4 +562,1231 @@ export interface AgentRpcMethodMap extends GatewayRpcMethodMap {
         params: undefined;
         result: ProductSummary[];
     };
+    "thread.user_response": {
+        params: {
+            requestId: string;
+            declined?: boolean;
+            answers?: Record<string, string>;
+        };
+        result: {
+            received: boolean;
+        };
+    };
+    "session.resolve": {
+        params: {
+            platform?: string;
+            chatId?: string;
+            chatType?: string;
+            userId?: string;
+            groupName?: string;
+            projectId?: string;
+            title?: string;
+        };
+        result: {
+            sessionId: string;
+            title?: string;
+            type: string;
+            agentId?: string;
+            ownerPlatform?: string;
+            ownerId?: string;
+            groupKey?: string;
+            groupPlatform?: string;
+            groupName?: string;
+            projectId?: string;
+        };
+    };
+    "session.focus": {
+        params: {
+            sessionId: string;
+            projectName?: string;
+        };
+        result: {
+            ok: false;
+        } | {
+            ok: true;
+            projectId: string;
+        };
+    };
+    "memory.atlas": GatewayRpcMethodMap["memory.atlas"];
+    "memory.activity": GatewayRpcMethodMap["memory.activity"];
+    "memory.observe": GatewayRpcMethodMap["memory.observe"];
+    "memory.propose": GatewayRpcMethodMap["memory.propose"];
+    "memory.consolidate": GatewayRpcMethodMap["memory.consolidate"];
+    "memory.update": GatewayRpcMethodMap["memory.update"];
+    "memory.attachment.adopt": GatewayRpcMethodMap["memory.attachment.adopt"];
+    "memory.attachment.locate": GatewayRpcMethodMap["memory.attachment.locate"];
+    "media.cancel": {
+        params: {
+            taskId: string;
+            provider?: string;
+        };
+        result: {
+            ok: true;
+        } | {
+            ok: false;
+            message: string;
+        };
+    };
+    "media.status": {
+        params: {
+            taskId: string;
+            provider?: string;
+        };
+        result: {
+            status: unknown;
+            message?: string;
+        };
+    };
+    "media.stt": {
+        params: {
+            audioBase64: string;
+            mimeType?: string;
+            language?: string;
+        };
+        result: {
+            text: string;
+            model?: string;
+        };
+    };
+    "settings.listProviders": {
+        params: undefined;
+        result: {
+            providers: Array<{
+                id: string;
+                displayName: string;
+                baseUrl: string;
+                modelCount: number;
+            }>;
+        };
+    };
+    "settings.addKey": {
+        params: {
+            providerId: string;
+            key: string;
+            label?: string;
+        };
+        result: {
+            keyId: string;
+            providerId: string;
+        };
+    };
+    "settings.removeKey": {
+        params: {
+            keyId: string;
+        };
+        result: {
+            ok: true;
+        };
+    };
+    "settings.getKey": {
+        params: {
+            keyId: string;
+        };
+        result: {
+            key: string;
+        };
+    };
+    "settings.copyKey": {
+        params: {
+            keyId: string;
+        };
+        result: {
+            ok: true;
+        };
+    };
+    "settings.toggleKey": {
+        params: {
+            keyId: string;
+            enabled: boolean;
+        };
+        result: {
+            ok: true;
+        };
+    };
+    "settings.toggleModel": {
+        params: {
+            modelId: string;
+            enabled: boolean;
+        };
+        result: {
+            ok: true;
+        };
+    };
+    "settings.listModels": {
+        params: {
+            purpose?: string;
+            provider?: string;
+        };
+        result: {
+            models: unknown[];
+            grouped: Record<string, unknown[]>;
+        };
+    };
+    "settings.setActiveModel": {
+        params: {
+            purpose: string;
+            modelId: string;
+        };
+        result: {
+            ok: true;
+        };
+    };
+    "settings.getActiveModel": {
+        params: {
+            purpose: string;
+        };
+        result: {
+            model: {
+                id: string;
+                provider: string;
+                model: string;
+                displayName: string;
+                routeIntents: string[];
+                capabilityProfile?: Record<string, unknown>;
+                enabled: boolean;
+            } | null;
+            available: boolean;
+        };
+    };
+    "settings.getOverview": {
+        params: undefined;
+        result: {
+            providers: Array<{
+                providerId: string;
+                baseUrl?: string;
+                keyCount: number;
+                healthyKeys: number;
+                totalKeys: number;
+            }>;
+            purposes: Record<string, {
+                bound: boolean;
+                modelId?: string;
+                modelName?: string;
+                available: boolean;
+            }>;
+        };
+    };
+    "settings.refreshModels": {
+        params: undefined;
+        result: {
+            ok: true;
+            catalogRefreshed?: boolean;
+        };
+    };
+    "settings.validateKey": {
+        params: {
+            providerId: string;
+            apiKey: string;
+            baseUrl?: string;
+        };
+        result: {
+            valid: boolean;
+            status: number;
+            error?: string;
+        };
+    };
+    "provider.list": {
+        params: undefined;
+        result: {
+            providers: Array<{
+                group: string;
+                variants: Array<{
+                    id: string;
+                    name: string;
+                    transport: string;
+                    baseUrl: string;
+                    defaultModel?: string;
+                    modelCount: number;
+                    available: boolean;
+                }>;
+            }>;
+        };
+    };
+    "config.tunables": {
+        params: undefined;
+        result: {
+            defaults: Record<string, unknown>;
+            overrides: Record<string, unknown>;
+        };
+    };
+    "config.updateTunable": {
+        params: {
+            key: string;
+            value?: unknown;
+        };
+        result: {
+            ok: true;
+            key: string;
+            value: unknown;
+        };
+    };
+    "community.getConsent": {
+        params: undefined;
+        result: {
+            ok: boolean;
+            remoteAvailable: boolean;
+            consent: {
+                enabled: boolean;
+                methodSharingEnabled: boolean;
+                signalsEnabled: boolean;
+                encounterEnabled: boolean;
+                remoteSynced: boolean;
+            };
+            error?: string;
+        };
+    };
+    "community.setConsent": {
+        params: {
+            enabled: boolean;
+            methodSharingEnabled?: boolean;
+            signalsEnabled?: boolean;
+            encounterEnabled?: boolean;
+        };
+        result: {
+            ok: boolean;
+            remoteAvailable: boolean;
+            consent: Record<string, unknown>;
+            warning?: string;
+        };
+    };
+    "community.matchRegistry": {
+        params: {
+            intent: string;
+            topK?: 1 | 2 | 3;
+            preferOfficial?: boolean;
+        };
+        result: {
+            ok: boolean;
+            matches: Array<Record<string, unknown>>;
+        };
+    };
+    "community.listShared": {
+        params: undefined;
+        result: {
+            ok: boolean;
+            resources: Array<Record<string, unknown>>;
+        };
+    };
+    "community.withdrawShared": {
+        params: {
+            resourceId: string;
+            reason?: string;
+        };
+        result: {
+            ok: boolean;
+            resource: Record<string, unknown>;
+        };
+    };
+    "community.withdrawAllShared": {
+        params: {
+            reason?: string;
+        };
+        result: {
+            ok: boolean;
+            resources: Array<Record<string, unknown>>;
+        };
+    };
+    "community.listNotices": {
+        params: {
+            includeRead?: boolean;
+        };
+        result: {
+            ok: boolean;
+            notices: Array<Record<string, unknown>>;
+        };
+    };
+    "community.markNoticeRead": {
+        params: {
+            noticeId: number;
+        };
+        result: {
+            ok: boolean;
+            notice: Record<string, unknown>;
+        };
+    };
+    "community.listPublishAudit": {
+        params: {
+            limit?: number;
+        };
+        result: {
+            ok: boolean;
+            entries: Array<Record<string, unknown>>;
+        };
+    };
+    "community.resolveInstall": {
+        params: {
+            resourceId: string;
+            version?: string;
+            explicitInstallConsent: true;
+            explicitHighRiskConsent?: true;
+        };
+        result: {
+            ok: boolean;
+            install: Record<string, unknown>;
+        };
+    };
+    "community.listResourceVersions": {
+        params: {
+            resourceId: string;
+        };
+        result: {
+            ok: true;
+            versions: unknown;
+        };
+    };
+    "community.getRatingSummary": {
+        params: {
+            resourceId: string;
+        };
+        result: {
+            ok: true;
+            summary: unknown;
+        };
+    };
+    "community.rateResource": {
+        params: {
+            resourceId: string;
+            stars: number;
+        };
+        result: {
+            ok: true;
+            summary: unknown;
+        };
+    };
+    "community.reportResource": {
+        params: {
+            resourceId: string;
+            reason?: string;
+        };
+        result: {
+            ok: true;
+        };
+    };
+    "community.listComments": {
+        params: {
+            resourceId: string;
+        };
+        result: {
+            ok: true;
+            comments: unknown;
+        };
+    };
+    "community.postComment": {
+        params: {
+            resourceId: string;
+            body: string;
+        };
+        result: {
+            ok: true;
+            comment: unknown;
+        };
+    };
+    "community.installResource": {
+        params: {
+            resourceId: string;
+            version?: string;
+            explicitInstallConsent: true;
+        };
+        result: {
+            ok: boolean;
+            installed?: Record<string, unknown>;
+            preview?: Record<string, unknown>;
+            signalWarning?: string;
+        };
+    };
+    "community.runtimeStatus": {
+        params: {
+            ids: string[];
+        };
+        result: {
+            ok: boolean;
+            items: Array<Record<string, unknown>>;
+        };
+    };
+    "community.installRuntime": {
+        params: {
+            id: string;
+        };
+        result: {
+            ok: boolean;
+            id: string;
+            version?: string;
+            binPath?: string;
+        };
+    };
+    "community.publishSkill": {
+        params: {
+            id: string;
+            title: string;
+            summary: string;
+            visibility?: "public" | "private";
+            tags?: string[];
+            manifest: Record<string, unknown>;
+            version?: string;
+            packageGzipBase64?: string;
+        };
+        result: {
+            ok: boolean;
+            resource: Record<string, unknown>;
+            version?: Record<string, unknown>;
+        };
+    };
+    "community.publishPet": {
+        params: {
+            id: string;
+            name: string;
+            summary: string;
+            persona: string;
+            visibility?: "public" | "private";
+            tags?: string[];
+            traits?: string[];
+            assets?: Array<{
+                kind: string;
+                path: string;
+            }>;
+        };
+        result: {
+            ok: boolean;
+            resource: Record<string, unknown>;
+            version?: Record<string, unknown>;
+        };
+    };
+    "community.recordSignal": {
+        params: {
+            resourceId: string;
+            event: string;
+            attribution?: string;
+            metadata?: Record<string, unknown>;
+        };
+        result: {
+            ok: boolean;
+            accepted: true;
+        };
+    };
+    "community.recordTelemetry": {
+        params: {
+            event: string;
+            metadata?: Record<string, unknown>;
+        };
+        result: {
+            ok: boolean;
+            accepted: true;
+        };
+    };
+    "agent.health": GatewayRpcMethodMap["agent.health"];
+    "agent.metrics": GatewayRpcMethodMap["agent.metrics"];
+    "agent.cancel": GatewayRpcMethodMap["agent.cancel"];
+    "agents.catalog": {
+        params: undefined;
+        result: {
+            catalog: Array<{
+                id: string;
+                name: string;
+                brandId: string;
+                category: string;
+                integration: string;
+                authMode: string;
+                note?: string;
+                status: string;
+                version: string | undefined;
+                install: {
+                    docsUrl?: string;
+                    command?: string;
+                };
+            }>;
+        };
+    };
+    "agents.checkUpdates": {
+        params: undefined;
+        result: {
+            updates: unknown[];
+        };
+    };
+    "agents.install": {
+        params: {
+            agentId: string;
+            mirror?: string;
+        };
+        result: {
+            ok: boolean;
+            error?: string;
+        };
+    };
+    "agents.prompt": {
+        params: {
+            agentId: string;
+            prompt: string;
+            cwd?: string;
+            timeoutMs?: number;
+            systemPrompt?: string;
+            sessionId?: string;
+            turnId?: string;
+            requestId?: string;
+            projectId?: string;
+        };
+        result: {
+            ok: true;
+            agentId: string;
+            content: string;
+            streamed: boolean;
+            stopReason?: string;
+            usage?: {
+                inputTokens: number;
+                outputTokens: number;
+                totalTokens: number;
+                cacheRead: number;
+                thoughtTokens: number;
+                cost: number;
+            };
+        };
+    };
+    "agents.approvalResponse": {
+        params: {
+            approvalId?: string;
+            optionId?: string;
+        };
+        result: {
+            ok: boolean;
+        };
+    };
+    "agents.warm": {
+        params: {
+            agentId?: string;
+        };
+        result: {
+            ok: boolean;
+            warmed: boolean;
+            error?: string;
+        };
+    };
+    "agents.getGateway": {
+        params: undefined;
+        result: AgentsGetGatewayResult;
+    };
+    "agents.processes": {
+        params: undefined;
+        result: AgentsProcessInfo[];
+    };
+    "agents.kill": {
+        params: AgentsKillParams;
+        result: {
+            ok: boolean;
+        };
+    };
+    "agents.listConfigured": {
+        params: undefined;
+        result: AgentsListConfiguredItem[];
+    };
+    "agents.getLog": {
+        params: AgentsGetLogParams;
+        result: AgentsGetLogResult;
+    };
+    "agents.testConnection": {
+        params: AgentsTestConnectionParams;
+        result: AgentsTestConnectionResult;
+    };
+    "solo.list": {
+        params: undefined;
+        result: SoloStatus[];
+    };
+    "solo.delete": {
+        params: SoloDeleteParams;
+        result: {
+            ok: true;
+        };
+    };
+    "solo.message": {
+        params: SoloMessageParams;
+        result: {
+            resultText: string;
+        };
+    };
+    "solo.evaluate": {
+        params: SoloEvaluateParams;
+        result: SoloEvaluation;
+    };
+    "product.plan": {
+        params: ProductPlanParams;
+        result: {
+            productId: string;
+            plan: ProductPlan;
+        };
+    };
+    "product.confirm": {
+        params: ProductConfirmParams;
+        result: {
+            productId: string;
+            ok: true;
+        };
+    };
+    "product.message": {
+        params: ProductMessageParams;
+        result: {
+            response: string;
+            plan?: ProductPlan;
+            mutations?: Array<{
+                type: string;
+                taskId: string;
+            }>;
+        };
+    };
+    "product.delete": {
+        params: ProductDeleteParams;
+        result: {
+            ok: true;
+        };
+    };
+    "product.cancel": {
+        params: ProductIdParams;
+        result: {
+            ok: true;
+        };
+    };
+    "product.rollback": {
+        params: ProductIdParams & {
+            checkpoint?: string;
+        };
+        result: {
+            ok: true;
+        };
+    };
+    "workflow.create": {
+        params: Record<string, unknown>;
+        result: Record<string, unknown>;
+    };
+    "workflow.get": {
+        params: {
+            id: string;
+            projectId?: string;
+            includePublished?: boolean;
+        };
+        result: Record<string, unknown>;
+    };
+    "workflow.describe": {
+        params: {
+            id: string;
+            projectId?: string;
+        };
+        result: {
+            rendered: string;
+        };
+    };
+    "workflow.patch": {
+        params: Record<string, unknown>;
+        result: Record<string, unknown>;
+    };
+    "workflow.run": {
+        params: Record<string, unknown>;
+        result: Record<string, unknown>;
+    };
+    "workflow.setActive": {
+        params: {
+            id: string;
+            active: boolean;
+            projectId?: string;
+        };
+        result: Record<string, unknown>;
+    };
+    "workflow.list": {
+        params: {
+            projectId?: string;
+        };
+        result: {
+            workflows: Array<Record<string, unknown>>;
+        };
+    };
+    "workflow.delete": {
+        params: {
+            id: string;
+            projectId?: string;
+        };
+        result: {
+            ok: true;
+        };
+    };
+    "workflow.onImMessage": {
+        params: {
+            channel: string;
+            text: string;
+            payload?: Record<string, unknown>;
+        };
+        result: {
+            outcomes: unknown[];
+            errors?: Array<{
+                projectId?: string;
+                error: string;
+            }>;
+        };
+    };
+    "workflow.onWebhook": {
+        params: {
+            path: string;
+            payload?: Record<string, unknown>;
+        };
+        result: {
+            outcomes: unknown[];
+            errors?: Array<{
+                projectId?: string;
+                error: string;
+            }>;
+            wokenWaits?: number;
+        };
+    };
+    "workflow.revisions": {
+        params: {
+            id: string;
+            projectId?: string;
+        };
+        result: {
+            revisions: unknown;
+        };
+    };
+    "workflow.revert": {
+        params: {
+            id: string;
+            rev: number;
+            projectId?: string;
+        };
+        result: Record<string, unknown>;
+    };
+    "workflow.runs": {
+        params: {
+            id: string;
+            projectId?: string;
+        };
+        result: {
+            runs: unknown;
+        };
+    };
+    "workflow.runDetail": {
+        params: {
+            id: string;
+            runId: string;
+            projectId?: string;
+        };
+        result: {
+            run: unknown;
+        };
+    };
+    "workflow.export": {
+        params: {
+            id: string;
+            projectId?: string;
+        };
+        result: {
+            bundle: unknown;
+        };
+    };
+    "workflow.import": {
+        params: {
+            payload: unknown;
+            format?: "n8n";
+            targetWorkflowId?: string;
+            id?: string;
+            name?: string;
+            projectId?: string;
+        };
+        result: Record<string, unknown>;
+    };
+    "workflow.duplicate": {
+        params: {
+            id: string;
+            targetProjectId?: string;
+            name?: string;
+            projectId?: string;
+        };
+        result: Record<string, unknown>;
+    };
+    "workflow.update": {
+        params: Record<string, unknown>;
+        result: Record<string, unknown>;
+    };
+    "workflow.capabilities": {
+        params: {
+            projectId?: string;
+        };
+        result: {
+            capabilities: unknown;
+        };
+    };
+    "workflow.onIntent": {
+        params: {
+            workflowId: string;
+            text: string;
+            surface?: string;
+            matchedPhrase?: string;
+            projectId?: string;
+        };
+        result: unknown;
+    };
+    "workflow.intentIndex": {
+        params: undefined;
+        result: {
+            intents: Array<{
+                workflowId: string;
+                projectId?: string;
+                name: string;
+                trigger: Record<string, unknown>;
+            }>;
+        };
+    };
+    "workflow.cancelRun": {
+        params: {
+            id: string;
+            runId?: string;
+            reason?: string;
+            projectId?: string;
+        };
+        result: Record<string, unknown>;
+    };
+    "workflow.setPermissionScope": {
+        params: {
+            id: string;
+            allowUnattendedKinds: string[] | null;
+            projectId?: string;
+        };
+        result: Record<string, unknown>;
+    };
+    "workflow.publish": {
+        params: {
+            id: string;
+            projectId?: string;
+        };
+        result: Record<string, unknown>;
+    };
+    "workflow.publishHub": {
+        params: {
+            id: string;
+            slug: string;
+            summary: string;
+            description?: string;
+            tags?: string[];
+            visibility?: "private" | "public";
+            category?: string;
+            version?: string;
+            projectId?: string;
+        };
+        result: {
+            ok: true;
+        } & Record<string, unknown>;
+    };
+    "workflow.audit": {
+        params: {
+            id?: string;
+            limit?: number;
+            projectId?: string;
+        };
+        result: {
+            entries: unknown;
+        };
+    };
+    "workflow.archive": {
+        params: {
+            id: string;
+            archived: boolean;
+            projectId?: string;
+        };
+        result: Record<string, unknown>;
+    };
+    "workflow.dryRun": {
+        params: {
+            id: string;
+            payload?: Record<string, unknown>;
+            projectId?: string;
+        };
+        result: Record<string, unknown>;
+    };
+    "workflow.metrics": {
+        params: {
+            id: string;
+            projectId?: string;
+        };
+        result: {
+            metrics: Record<string, unknown>;
+        };
+    };
+    "workflow.approve": {
+        params: {
+            approvalId: string;
+            approved: boolean;
+            note?: string;
+        };
+        result: {
+            ok: true;
+        };
+    };
+    "workflow.approvals": {
+        params: undefined;
+        result: {
+            approvals: Array<Record<string, unknown>>;
+        };
+    };
+    "workflow.onForm": {
+        params: {
+            workflowId: string;
+            values: Record<string, unknown>;
+            projectId?: string;
+        };
+        result: unknown;
+    };
+    "credential.list": {
+        params: undefined;
+        result: {
+            credentials: Array<Record<string, unknown>>;
+        };
+    };
+    "credential.create": {
+        params: {
+            type: string;
+            label: string;
+            data: Record<string, unknown>;
+            meta?: Record<string, unknown>;
+        };
+        result: Record<string, unknown>;
+    };
+    "credential.delete": {
+        params: {
+            id: string;
+        };
+        result: {
+            ok: boolean;
+        };
+    };
+    "credential.oauthStart": {
+        params: {
+            label: string;
+            authUrl: string;
+            tokenUrl: string;
+            clientId: string;
+            redirectUri: string;
+            scopes?: string;
+            clientSecret?: string;
+        };
+        result: {
+            credentialId: string;
+            authorizeUrl: string;
+            state: string;
+        };
+    };
+    "credential.oauthComplete": {
+        params: {
+            state: string;
+            code: string;
+        };
+        result: {
+            ok: true;
+            credentialId: string;
+        };
+    };
+    "project.purgeAll": GatewayRpcMethodMap["project.purgeAll"];
+    "session.moveToProject": GatewayRpcMethodMap["session.moveToProject"];
+    "instructions.list": GatewayRpcMethodMap["instructions.list"];
+    "instructions.read": GatewayRpcMethodMap["instructions.read"];
+    "instructions.write": GatewayRpcMethodMap["instructions.write"];
+    "instructions.delete": GatewayRpcMethodMap["instructions.delete"];
+    "plans.list": {
+        params: {
+            projectId?: string;
+        };
+        result: {
+            plans: Array<{
+                slug: string;
+                name: string;
+                title: string;
+                status?: string;
+                path: string;
+                size: number;
+            }>;
+        };
+    };
+    "skills.activate": {
+        params: {
+            name: string;
+        };
+        result: {
+            ok: true;
+            already: boolean;
+        };
+    };
+    "skills.deactivate": {
+        params: {
+            name: string;
+        };
+        result: {
+            ok: true;
+            already: boolean;
+        };
+    };
+    "skills.delete": {
+        params: {
+            name: string;
+            scope?: "project" | "global";
+        };
+        result: {
+            ok: true;
+            deleted: string;
+            scope: string;
+            signalStatus?: string;
+        };
+    };
+    "skills.promote": {
+        params: {
+            name: string;
+            keepLocal?: boolean;
+        };
+        result: {
+            ok: true;
+            promoted: string;
+            scope: "global";
+            globalPath: string;
+            removedFromProject: boolean;
+        };
+    };
+    "skills.stats": {
+        params: {
+            name?: string;
+        };
+        result: {
+            name?: string;
+            stats: unknown;
+        };
+    };
+    "skills.pin": {
+        params: {
+            name: string;
+        };
+        result: {
+            name: string;
+            pinned: true;
+        };
+    };
+    "skills.unpin": {
+        params: {
+            name: string;
+        };
+        result: {
+            name: string;
+            pinned: false;
+        };
+    };
+    "skills.curator": {
+        params: undefined;
+        result: Record<string, unknown>;
+    };
+    "skills.lifecycle": {
+        params: {
+            state?: string;
+            name?: string;
+        };
+        result: {
+            record?: unknown;
+        } | {
+            records: unknown[];
+        };
+    };
+    "pet.interact": {
+        params: {
+            action?: string;
+        };
+        result: {
+            ok: true;
+            action: string;
+            level: number;
+            experience: number;
+            events: Array<{
+                type: string;
+                level: number;
+            }>;
+            reaction: {
+                text: string;
+                style: "normal" | "thinking" | "excited" | "sleepy";
+            } | null;
+        };
+    };
+    "pet.status": {
+        params: undefined;
+        result: {
+            ok: true;
+        } & Record<string, unknown>;
+    };
+    "pet.forge": {
+        params: {
+            description?: string;
+            imageBase64?: string;
+            imageMimeType?: string;
+            imageFileName?: string;
+            mode?: string;
+            basePetId?: string;
+            basePetName?: string;
+        };
+        result: {
+            ok: true;
+            asset: Record<string, unknown>;
+            manifest: unknown;
+            productionRun: unknown;
+            profile: Record<string, unknown>;
+            status: "complete";
+        };
+    };
+    "pet.asset.import": {
+        params: {
+            fileName?: string;
+            contentType?: string;
+            packageBase64: string;
+        };
+        result: {
+            ok: true;
+            asset: Record<string, unknown>;
+        } & Record<string, unknown>;
+    };
+    "pet.preferences.update": {
+        params: {
+            enabled?: boolean;
+            selectedPetAssetId?: string;
+        };
+        result: {
+            ok: true;
+        } & Record<string, unknown>;
+    };
+    "pet.journey.snapshot": {
+        params: Record<string, unknown>;
+        result: {
+            ok: true;
+            profile: Record<string, unknown>;
+            dates: unknown;
+        };
+    };
+    "pet.journey.list": {
+        params: undefined;
+        result: {
+            ok: true;
+            dates: string[];
+        };
+    };
+    "pet.journey.get": {
+        params: {
+            date?: string;
+        };
+        result: {
+            ok: true;
+            snapshot: unknown | null;
+        };
+    };
+    "pet.custom.delete": {
+        params: {
+            id: string;
+        };
+        result: {
+            ok: true;
+        } & Record<string, unknown>;
+    };
+    "pet.confirm_response": {
+        params: {
+            confirmId: string;
+            approved: boolean;
+        };
+        result: {
+            ok: true;
+        };
+    };
 }