@nikcli-ai/sdk 1.309.0 → 1.311.0

package/dist/httpapi/compat.d.ts

@@ -1,5 +1,5 @@
 import { make, type RequestOptions } from "./generated/client.js";
-type Raw = ReturnType<typeof make>;
+export type Raw = ReturnType<typeof make>;
 /**
  * Result envelope. Transport failures and declared HTTP errors resolve as
  * `error` rather than rejecting, so a failed call in a UI event handler cannot
@@ -35,9 +35,31 @@ type Selector = {
 };
 /** Selection passed inline with the request body. */
 type WithDirectory<I> = I & Selector;
+/** An input the caller may omit entirely: optional parameter, or no required field. */
+type Omittable<I> = undefined extends I ? true : {} extends I ? true : false;
+type Result0<F> = F extends (options?: RequestOptions) => Promise<infer R> ? (options?: CallOptions, overrides?: CallOptions) => Promise<Result<R>> : never;
+type ResultN<F> = F extends (input: infer I, options?: RequestOptions) => Promise<infer R> ? Omittable<I> extends true ? (input?: WithDirectory<NonNullable<I>>, options?: CallOptions) => Promise<Result<R>> : (input: WithDirectory<I>, options?: CallOptions) => Promise<Result<R>> : never;
+type ResultAt<F> = F extends (input: infer I, options?: RequestOptions) => Promise<infer R> ? Omittable<I> extends true ? (input?: NonNullable<I>, options?: CallOptions) => Promise<Result<R>> : (input: I, options?: CallOptions) => Promise<Result<R>> : never;
+type Stream0<F> = F extends (options?: RequestOptions) => AsyncIterable<infer R> ? (options?: CallOptions, overrides?: CallOptions) => Promise<{
+    stream: AsyncIterable<R>;
+}> : never;
+type StreamN<F> = F extends (input: infer I, options?: RequestOptions) => AsyncIterable<infer R> ? Omittable<I> extends true ? (input?: WithDirectory<NonNullable<I>>, options?: CallOptions) => Promise<{
+    stream: AsyncIterable<R>;
+}> : (input: WithDirectory<I>, options?: CallOptions) => Promise<{
+    stream: AsyncIterable<R>;
+}> : never;
+type AnyFn = (...args: any[]) => any;
 export type CompatDefaults = {
     readonly throwOnError?: boolean;
 };
+declare function helpers(defaults: CompatDefaults): {
+    result0: <F extends AnyFn>(fn: F) => Result0<F>;
+    result: <F extends AnyFn>(fn: F) => ResultN<F>;
+    resultAt: <F extends AnyFn>(fn: F) => ResultAt<F>;
+    stream0: <F extends AnyFn>(fn: F) => Stream0<F>;
+    stream: <F extends AnyFn>(fn: F) => StreamN<F>;
+};
+export type CompatHelpers = ReturnType<typeof helpers>;
 export declare function compat(raw: Raw, defaults?: CompatDefaults): {
     analytics: {
         daily: (input?: (import("./client.js").AnalyticsDailyInput & Selector) | undefined, options?: CallOptions) => Promise<Result<import("./client.js").AnalyticsDailyOutput>>;
@@ -220,9 +242,25 @@ export declare function compat(raw: Raw, defaults?: CompatDefaults): {
             };
         };
         bootstrap: (options?: CallOptions, overrides?: CallOptions) => Promise<Result<import("./client.js").MobileBootstrap>>;
+        brain: {
+            get: (options?: CallOptions, overrides?: CallOptions) => Promise<Result<import("./client.js").MobileBrainStatusOutput>>;
+            trigger: (input: WithDirectory<import("./client.js").MobileBrainTriggerInput>, options?: CallOptions) => Promise<Result<import("./client.js").MobileBrainTriggerOutput>>;
+        };
+        chatbot: {
+            list: (options?: CallOptions, overrides?: CallOptions) => Promise<Result<import("./client.js").MobileChatBotListOutput>>;
+            start: (input: WithDirectory<import("./client.js").MobileChatBotStartInput>, options?: CallOptions) => Promise<Result<import("./client.js").MobileChatBotStartOutput>>;
+            stop: (input: WithDirectory<import("./client.js").MobileChatBotStopInput>, options?: CallOptions) => Promise<Result<import("./client.js").MobileChatBotStopOutput>>;
+        };
         command: {
             list: (options?: CallOptions, overrides?: CallOptions) => Promise<Result<import("./client.js").MobileCommandListOutput>>;
         };
+        events: (options?: CallOptions, overrides?: CallOptions) => Promise<{
+            stream: AsyncIterable<unknown>;
+        }>;
+        fusion: {
+            list: (options?: CallOptions, overrides?: CallOptions) => Promise<Result<import("./client.js").MobileFusionListOutput>>;
+            set: (input: WithDirectory<import("./client.js").MobileFusionSetInput>, options?: CallOptions) => Promise<Result<import("./client.js").MobileFusionSetOutput>>;
+        };
         git: {
             branches: (options?: CallOptions, overrides?: CallOptions) => Promise<Result<import("./client.js").MobileGitBranchesOutput>>;
             checkout: (input: WithDirectory<import("./client.js").MobileGitCheckoutInput>, options?: CallOptions) => Promise<Result<import("./client.js").MobileSuccess>>;
@@ -260,6 +298,19 @@ export declare function compat(raw: Raw, defaults?: CompatDefaults): {
                 publish: (input: WithDirectory<import("./client.js").MobileSessionPublishInput>, options?: CallOptions) => Promise<Result<import("./client.js").MobileGithubPublishResult>>;
             };
         };
+        host: {
+            browser: (options?: CallOptions, overrides?: CallOptions) => Promise<Result<import("./client.js").MobileHostBrowserOutput>>;
+            computer: (options?: CallOptions, overrides?: CallOptions) => Promise<Result<import("./client.js").MobileHostComputerOutput>>;
+            devtools: (options?: CallOptions, overrides?: CallOptions) => Promise<Result<import("./client.js").MobileHostDevtoolsOutput>>;
+            herdr: {
+                get: (options?: CallOptions, overrides?: CallOptions) => Promise<Result<import("./client.js").MobileHostHerdrGetOutput>>;
+                set: (input: WithDirectory<import("./client.js").MobileHostHerdrSetInput>, options?: CallOptions) => Promise<Result<import("./client.js").MobileHostHerdrSetOutput>>;
+            };
+            island: (options?: CallOptions, overrides?: CallOptions) => Promise<Result<import("./client.js").MobileHostIslandOutput>>;
+        };
+        lsp: {
+            status: (options?: CallOptions, overrides?: CallOptions) => Promise<Result<import("./client.js").MobileLspStatusOutput>>;
+        };
         loop: {
             abort: (input: WithDirectory<import("./client.js").MobileLoopAbortInput>, options?: CallOptions) => Promise<Result<import("./client.js").MobileSuccess>>;
             create: (input: WithDirectory<import("./client.js").MobileLoopCreateInput>, options?: CallOptions) => Promise<Result<import("./client.js").LoopDefinition>>;
@@ -287,6 +338,29 @@ export declare function compat(raw: Raw, defaults?: CompatDefaults): {
                 list: (options?: CallOptions, overrides?: CallOptions) => Promise<Result<import("./client.js").MobileMemoryStashListOutput>>;
             };
         };
+        mission: {
+            cancel: (input: WithDirectory<import("./client.js").MobileMissionCancelInput>, options?: CallOptions) => Promise<Result<import("./client.js").MobileSuccess>>;
+            create: (input: WithDirectory<import("./client.js").MobileMissionCreateInput>, options?: CallOptions) => Promise<Result<import("./client.js").MobileMissionDefinition>>;
+            delete: (input: WithDirectory<import("./client.js").MobileMissionDeleteInput>, options?: CallOptions) => Promise<Result<import("./client.js").MobileSuccess>>;
+            execs: (input: WithDirectory<import("./client.js").MobileMissionExecsInput>, options?: CallOptions) => Promise<Result<import("./client.js").MobileMissionExecsOutput>>;
+            execs2: {
+                recent: (input?: (import("./client.js").MobileMissionExecsRecentInput & Selector) | undefined, options?: CallOptions) => Promise<Result<import("./client.js").MobileMissionExecsRecentOutput>>;
+            };
+            feature: {
+                mutate: (input: WithDirectory<import("./client.js").MobileMissionFeatureMutateInput>, options?: CallOptions) => Promise<Result<import("./client.js").MobileMissionDefinition>>;
+            };
+            generate: (input: WithDirectory<import("./client.js").MobileMissionGenerateInput>, options?: CallOptions) => Promise<Result<import("./client.js").MobileMissionDefinition>>;
+            get: (input: WithDirectory<import("./client.js").MobileMissionGetInput>, options?: CallOptions) => Promise<Result<import("./client.js").MobileMissionGetOutput>>;
+            list: (options?: CallOptions, overrides?: CallOptions) => Promise<Result<import("./client.js").MobileMissionListOutput>>;
+            pause: (input: WithDirectory<import("./client.js").MobileMissionPauseInput>, options?: CallOptions) => Promise<Result<import("./client.js").MobileSuccess>>;
+            start: (input: WithDirectory<import("./client.js").MobileMissionStartInput>, options?: CallOptions) => Promise<Result<import("./client.js").MobileSuccess>>;
+            templates: (options?: CallOptions, overrides?: CallOptions) => Promise<Result<import("./client.js").MobileMissionTemplatesOutput>>;
+            update: (input: WithDirectory<import("./client.js").MobileMissionUpdateInput>, options?: CallOptions) => Promise<Result<import("./client.js").MobileMissionDefinition>>;
+        };
+        observability: {
+            get: (options?: CallOptions, overrides?: CallOptions) => Promise<Result<import("./client.js").MobileObservabilityGetOutput>>;
+            set: (input: WithDirectory<import("./client.js").MobileObservabilitySetInput>, options?: CallOptions) => Promise<Result<import("./client.js").MobileObservabilitySetOutput>>;
+        };
         permission: {
             respond: (input: WithDirectory<import("./client.js").MobilePermissionRespondInput>, options?: CallOptions) => Promise<Result<import("./client.js").MobileSuccess>>;
         };
@@ -339,11 +413,12 @@ export declare function compat(raw: Raw, defaults?: CompatDefaults): {
                     chunk: (input: WithDirectory<import("./client.js").MobileTeleportUploadChunkInput>, options?: CallOptions) => Promise<Result<import("./client.js").MobileTeleportUploadChunkOutput>>;
                 };
             };
+            todo: (input: WithDirectory<import("./client.js").MobileSessionTodoInput>, options?: CallOptions) => Promise<Result<import("./client.js").MobileSessionTodoOutput>>;
         };
         worktree: {
             create: (input?: (import("./client.js").MobileWorktreeCreateInput & Selector) | undefined, options?: CallOptions) => Promise<Result<import("./client.js").Worktree>>;
-            remove: (input: WithDirectory<import("./client.js").MobileWorktreeRemoveInput>, options?: CallOptions) => Promise<Result<import("./client.js").MobileSuccess>>;
-            reset: (input: WithDirectory<import("./client.js").MobileWorktreeResetInput>, options?: CallOptions) => Promise<Result<import("./client.js").MobileSuccess>>;
+            remove: (input: import("./client.js").MobileWorktreeRemoveInput, options?: CallOptions) => Promise<Result<import("./client.js").MobileSuccess>>;
+            reset: (input: import("./client.js").MobileWorktreeResetInput, options?: CallOptions) => Promise<Result<import("./client.js").MobileSuccess>>;
         };
     };
     part: {
@@ -375,6 +450,14 @@ export declare function compat(raw: Raw, defaults?: CompatDefaults): {
     };
     project: {
         current: (options?: CallOptions, overrides?: CallOptions) => Promise<Result<import("./client.js").Project>>;
+        copy: {
+            create: (input: import("./client.js").ProjectCopyCreateInput, options?: CallOptions) => Promise<Result<import("./client.js").ProjectCopy>>;
+            refresh: (input: WithDirectory<import("./client.js").ProjectCopyRefreshInput>, options?: CallOptions) => Promise<Result<import("./client.js").ProjectCopyRefresh>>;
+            remove: (input: import("./client.js").ProjectCopyRemoveInput, options?: CallOptions) => Promise<Result<void>>;
+        };
+        directory: {
+            list: (input: WithDirectory<import("./client.js").ProjectDirectoryListInput>, options?: CallOptions) => Promise<Result<import("./client.js").ProjectDirectoryListOutput>>;
+        };
         list: (options?: CallOptions, overrides?: CallOptions) => Promise<Result<import("./client.js").ProjectListOutput>>;
         update: (input: WithDirectory<import("./client.js").ProjectUpdateInput>, options?: CallOptions) => Promise<Result<import("./client.js").Project>>;
     };
@@ -425,6 +508,7 @@ export declare function compat(raw: Raw, defaults?: CompatDefaults): {
         instructions: (input: WithDirectory<import("./client.js").SessionInstructionsInput>, options?: CallOptions) => Promise<Result<import("./client.js").SessionInstructionList>>;
         list: (input?: import("./client.js").SessionListInput | undefined, options?: CallOptions) => Promise<Result<import("./client.js").SessionList>>;
         message: (input: WithDirectory<import("./client.js").SessionMessageInput>, options?: CallOptions) => Promise<Result<import("./client.js").MessageWithParts>>;
+        messageDelete: (input: WithDirectory<import("./client.js").SessionMessageRemoveInput>, options?: CallOptions) => Promise<Result<boolean>>;
         messages: (input: WithDirectory<import("./client.js").SessionMessagesInput>, options?: CallOptions) => Promise<Result<import("./client.js").MessageList>>;
         monitor: (input: WithDirectory<import("./client.js").SessionMonitorInput>, options?: CallOptions) => Promise<Result<import("./client.js").SessionMonitorOutput2>>;
         monitorCancel: (input: WithDirectory<import("./client.js").SessionMonitorCancelInput>, options?: CallOptions) => Promise<Result<import("./client.js").SessionMonitorOutput2>>;
@@ -505,5 +589,9 @@ export declare function compat(raw: Raw, defaults?: CompatDefaults): {
         remove: (input: import("./client.js").ExperimentalWorktreeRemoveInput, options?: CallOptions) => Promise<Result<boolean>>;
         reset: (input: import("./client.js").ExperimentalWorktreeResetInput, options?: CallOptions) => Promise<Result<boolean>>;
     };
+    getAccount: (options?: CallOptions, overrides?: CallOptions) => Promise<Result<unknown>>;
+    getConfigProfiles: (options?: CallOptions, overrides?: CallOptions) => Promise<Result<import("./client.js").ConfigProfilesList>>;
+    postAccountLogin: (options?: CallOptions, overrides?: CallOptions) => Promise<Result<unknown>>;
+    postAccountLoginComplete: (input: WithDirectory<import("./client.js").AccountCompleteInput>, options?: CallOptions) => Promise<Result<unknown>>;
 };
 export {};

package/dist/httpapi/compat.js

@@ -1,10 +1,11 @@
 // Namespaced view of the generated Promise client, keyed the way callers are.
 //
-// Derived once from the shape of the retired hey-api client, then maintained by
-// hand. Every entry is a typed reference into `./generated/client.ts`, so a
-// codegen rename surfaces here as a typecheck failure rather than a runtime 404.
+// Generated from the exhaustive declaration beside PublicApi. Every leaf is a
+// typed reference into `./generated/client.ts`, so contract drift fails client
+// generation instead of disappearing from this view or becoming a runtime 404.
 // See packages/nikcli/AGENTS.md, "HTTP integration workflow".
 import { ClientError } from "./generated/client-error.js";
+import { makeCompat } from "./generated/compat.js";
 function helpers(defaults) {
     /**
      * Splits the caller's options into the transport options the generated client
@@ -68,465 +69,5 @@ function helpers(defaults) {
     return { result0, result, resultAt, stream0, stream };
 }
 export function compat(raw, defaults = {}) {
-    const { result0, result, resultAt, stream0, stream } = helpers(defaults);
-    return {
-        analytics: {
-            daily: result(raw.analytics.daily),
-            data: result(raw.analytics.data),
-            global: result0(raw.analytics.global),
-            leaderboard: result0(raw.analytics.leaderboard),
-            session: result(raw.analytics.session),
-            sessions: result0(raw.analytics.sessions),
-        },
-        app: {
-            agents: result0(raw["top-level"].agent),
-            log: result(raw.app.log),
-            skill: {
-                create: result(raw.app.skillCreate),
-                delete: result(raw.app.skillDelete),
-            },
-            skills: result0(raw["top-level"].skill),
-        },
-        auth: {
-            remove: result(raw.auth.remove),
-            set: result(raw.auth.set),
-        },
-        brain: {
-            status: result0(raw.brain.status),
-            trigger: result(raw.brain.trigger),
-        },
-        chatbot: {
-            bots: result0(raw.chatbot.bots),
-            start: result(raw.chatbot.start),
-            stop: result(raw.chatbot.stop),
-        },
-        discord: {
-            status: result0(raw.discord.status),
-            setup: result(raw.discord.setup),
-            start: result0(raw.discord.start),
-            stop: result0(raw.discord.stop),
-        },
-        voice: {
-            transcribe: result(raw.voice.transcribe),
-        },
-        command: {
-            list: result0(raw["top-level"].command),
-        },
-        config: {
-            get: result0(raw.config.get),
-            providers: result0(raw.config.providers),
-            reload: result0(raw["config-management"].reload),
-            update: result(raw.config.update),
-        },
-        connectors: {
-            auth: {
-                remove: result(raw.connectors.authRemove),
-                set: result(raw.connectors.authSet),
-            },
-            invalidate: result(raw.connectors.invalidate),
-            status: result0(raw.connectors.status),
-        },
-        deleteConfigMcpName: result(raw["config-management"].mcpRemove),
-        doctor: {
-            run: result0(raw.doctor.run),
-        },
-        event: {
-            subscribe: stream0(raw.events.subscribe),
-        },
-        experimental: {
-            resource: {
-                list: result0(raw.experimental.resource),
-            },
-            workspace: {
-                adaptor: {
-                    list: result0(raw.workspace.adaptors),
-                },
-                create: result(raw.workspace.create),
-                events: result(raw["workspace-extra"].events),
-                list: result0(raw.workspace.list),
-                remove: result(raw.workspace.remove),
-                restore: result(raw.workspace.restore),
-                session: {
-                    restore: result(raw.workspace.sessionRestore),
-                    warp: result(raw["workspace-extra"].sessionWarp),
-                },
-                status: result0(raw.workspace.status),
-                syncList: result0(raw.workspace.syncList),
-                warp: result(raw.workspace.warp),
-            },
-        },
-        file: {
-            list: result(raw.file.list),
-            read: result(raw.file.content),
-            status: result0(raw.file.status),
-            write: result(raw.file.write),
-        },
-        find: {
-            files: result(raw.file.findFile),
-            symbols: result(raw.file.findSymbol),
-            text: result(raw.file.findText),
-        },
-        formatter: {
-            status: result0(raw["top-level"].formatter),
-        },
-        getApiShareShareId: result(raw.share.api),
-        getApiShareShareIdData: result(raw.share.data),
-        getShareShareId: result(raw.share.page),
-        getSShareId: result(raw.share.short),
-        global: {
-            dispose: result0(raw.global.dispose),
-            event: stream0(raw.events.global),
-            health: result0(raw.global.health),
-        },
-        instance: {
-            dispose: result0(raw["top-level"].dispose),
-        },
-        loop: {
-            abort: result(raw.loop.abort),
-            delete: result(raw.loop.remove),
-            generate: result(raw.loop.generate),
-            get: result(raw.loop.get),
-            list: result0(raw.loop.list),
-            pause: result(raw.loop.pause),
-            recentRuns: result(raw.loop.recentRuns),
-            resume: result(raw.loop.resume),
-            run: result(raw.loop.run),
-            runs: result(raw.loop.runs),
-            templates: result0(raw.loop.templates),
-            toggle: result(raw.loop.toggle),
-            update: result(raw.loop.update),
-            upsert: result(raw.loop.upsert),
-        },
-        lsp: {
-            status: result0(raw["top-level"].lsp),
-        },
-        managedWorktree: {
-            ancestors: result(raw.experimental.managedWorktreeAncestors),
-            children: result(raw.experimental.managedWorktreeChildren),
-            create: result(raw.experimental.managedWorktreeCreate),
-            link: result(raw.experimental.managedWorktreeLink),
-            list: result0(raw.experimental.managedWorktreeList),
-            remove: result(raw.experimental.managedWorktreeRemove),
-        },
-        mcp: {
-            add: result(raw.mcp.add),
-            auth: {
-                authenticate: result(raw.mcp.authenticate),
-                callback: result(raw.mcp.authCallback),
-                remove: result(raw.mcp.removeAuth),
-                start: result(raw.mcp.startAuth),
-            },
-            connect: result(raw.mcp.connect),
-            disconnect: result(raw.mcp.disconnect),
-            status: result0(raw.mcp.status),
-            toggle: result(raw.mcp.toggle),
-        },
-        mission: {
-            cancel: result(raw.mission.cancel),
-            delete: result(raw.mission.remove),
-            execs: result(raw.mission.execs),
-            feature: {
-                mutate: result(raw.mission.featureMutate),
-            },
-            generate: result(raw.mission.generate),
-            get: result(raw.mission.get),
-            list: result0(raw.mission.list),
-            pause: result(raw.mission.pause),
-            recentExecs: result(raw.mission.recentExecs),
-            start: result(raw.mission.start),
-            templates: result0(raw.mission.templates),
-            update: result(raw.mission.update),
-            upsert: result(raw.mission.upsert),
-        },
-        mobile: {
-            auth: {
-                token: {
-                    create: result(raw.mobile.authTokenCreate),
-                    list: result0(raw.mobile.authTokenList),
-                    revoke: result(raw.mobile.authTokenRevoke),
-                },
-            },
-            bootstrap: result0(raw.mobile.bootstrap),
-            command: {
-                list: result0(raw.mobile.commandList),
-            },
-            git: {
-                branches: result0(raw.mobile.gitBranches),
-                checkout: result(raw.mobile.gitCheckout),
-                commit: result(raw.mobile.gitCommit),
-                commits: result(raw.mobile.gitCommits),
-                diff: result(raw.mobile.gitDiff),
-                discard: result(raw.mobile.gitDiscard),
-                pull: result0(raw.mobile.gitPull),
-                push: result(raw.mobile.gitPush),
-                stage: result(raw.mobile.gitStage),
-                status: result0(raw.mobile.gitStatus),
-                unstage: result(raw.mobile.gitUnstage),
-            },
-            github: {
-                auth: {
-                    remove: result0(raw.mobile.githubAuthRemove),
-                    set: result(raw.mobile.githubAuthSet),
-                },
-                branches: result(raw.mobile.githubBranches),
-                import: result(raw.mobile.githubImport),
-                imports: result0(raw.mobile.githubImports),
-                oauth: {
-                    clientId: {
-                        set: result(raw.mobile.githubOauthClient),
-                    },
-                    device: {
-                        poll: result(raw.mobile.githubOauthDevicePoll),
-                        start: result0(raw.mobile.githubOauthDeviceStart),
-                    },
-                },
-                repos: result0(raw.mobile.githubRepos),
-                session: {
-                    cleanup: result(raw.mobile.sessionCleanup),
-                    create: result(raw.mobile.githubSessionCreate),
-                    publish: result(raw.mobile.sessionPublish),
-                },
-            },
-            loop: {
-                abort: result(raw.mobile.loopAbort),
-                create: result(raw.mobile.loopCreate),
-                delete: result(raw.mobile.loopDelete),
-                generate: result(raw.mobile.loopGenerate),
-                get: result(raw.mobile.loopGet),
-                list: result0(raw.mobile.loopList),
-                pause: result(raw.mobile.loopPause),
-                resume: result(raw.mobile.loopResume),
-                run: result(raw.mobile.loopRun),
-                runs: result(raw.mobile.loopRuns),
-                runs2: {
-                    recent: result(raw.mobile.loopRunsRecent),
-                },
-                templates: result0(raw.mobile.loopTemplates),
-                toggle: result(raw.mobile.loopToggle),
-                update: result(raw.mobile.loopUpdate),
-            },
-            memory: {
-                history: result0(raw.mobile.memoryHistory),
-                search: result(raw.mobile.memorySearch),
-                stash: {
-                    create: result(raw.mobile.memoryStashCreate),
-                    delete: result(raw.mobile.memoryStashDelete),
-                    list: result0(raw.mobile.memoryStashList),
-                },
-            },
-            permission: {
-                respond: result(raw.mobile.permissionRespond),
-            },
-            project: {
-                list: result0(raw.mobile.projectList),
-            },
-            pty: {
-                create: result(raw.mobile.ptyCreate),
-                get: result(raw.mobile.ptyGet),
-                list: result0(raw.mobile.ptyList),
-                remove: result(raw.mobile.ptyRemove),
-                update: result(raw.mobile.ptyUpdate),
-            },
-            question: {
-                reject: result(raw.mobile.questionReject),
-                respond: result(raw.mobile.questionRespond),
-            },
-            routine: {
-                create: result(raw.mobile.routineCreate),
-                delete: result(raw.mobile.routineDelete),
-                get: result(raw.mobile.routineGet),
-                list: result0(raw.mobile.routineList),
-                pause: result(raw.mobile.routinePause),
-                resume: result(raw.mobile.routineResume),
-                run: result(raw.mobile.routineRun),
-                trigger: result(raw.mobile.routineTrigger),
-                update: result(raw.mobile.routineUpdate),
-            },
-            session: {
-                abort: result(raw.mobile.sessionAbort),
-                command: result(raw.mobile.sessionCommand),
-                command2: {
-                    list: result(raw.mobile.sessionCommandList),
-                },
-                create: result(raw.mobile.sessionCreate),
-                delete: result(raw.mobile.sessionDelete),
-                detail: result(raw.mobile.sessionDetail),
-                diff: result(raw.mobile.sessionDiff),
-                list: result(raw.mobile.sessionList),
-                message: result(raw.mobile.sessionMessage),
-                rename: result(raw.mobile.sessionRename),
-                stream: stream(raw.mobile.sessionStream),
-                teleport: result(raw.mobile.teleportIn),
-                teleport2: {
-                    out: result(raw.mobile.teleportOut),
-                    upload: {
-                        begin: result0(raw.mobile.teleportUploadBegin),
-                        chunk: result(raw.mobile.teleportUploadChunk),
-                    },
-                },
-            },
-            worktree: {
-                create: result(raw.mobile.worktreeCreate),
-                remove: result(raw.mobile.worktreeRemove),
-                reset: result(raw.mobile.worktreeReset),
-            },
-        },
-        part: {
-            delete: result(raw.session.partRemove),
-            update: result(raw.session.partUpdate),
-        },
-        patchConfigMcpName: result(raw["config-management"].mcpUpdate),
-        patchUserId: result(raw.users.update),
-        path: {
-            get: result0(raw["top-level"].path),
-        },
-        permission: {
-            list: result0(raw.permission.list),
-            reply: result(raw.permission.reply),
-            respond: result(raw.session.permissionRespond),
-        },
-        postConfigMcp: result(raw["config-management"].mcpAdd),
-        postConfigProfiles: result(raw["config-management"].profileCreate),
-        postConfigProfilesActivateName: result(raw["config-management"].profileActivate),
-        postUserLogin: result(raw.users.login),
-        postUserRegister: result(raw.users.register),
-        profile: {
-            clear: result0(raw.profile.clear),
-            clearHabits: result(raw.profile.clearHabits),
-            get: result0(raw.profile.get),
-            habits: result(raw.profile.habits),
-            patch: result(raw.profile.patch),
-            preview: result(raw.profile.preview),
-        },
-        project: {
-            current: result0(raw.project.current),
-            list: result0(raw.project.list),
-            update: result(raw.project.update),
-        },
-        provider: {
-            api: {
-                set: result(raw.provider.api),
-            },
-            auth: result0(raw.provider.auth),
-            auth2: {
-                remove: result(raw.provider.removeAuth),
-            },
-            list: result0(raw.provider.list),
-            oauth: {
-                authorize: result(raw.provider.oauthAuthorize),
-                callback: result(raw.provider.oauthCallback),
-            },
-        },
-        pty: {
-            create: result(raw.pty.create),
-            get: result(raw.pty.get),
-            list: result0(raw.pty.list),
-            remove: result(raw.pty.remove),
-            update: result(raw.pty.update),
-        },
-        question: {
-            list: result0(raw.question.list),
-            reject: result(raw.question.reject),
-            reply: result(raw.question.reply),
-        },
-        session: {
-            abort: result(raw.session.abort),
-            background: result(raw.session.background),
-            background2: {
-                cancel: result(raw.session.backgroundCancel),
-                inspect: result(raw.session.backgroundInspect),
-                read: result(raw.session.backgroundRead),
-            },
-            children: result(raw.session.children),
-            command: result(raw.session.command),
-            context: result(raw.session.contextBreakdown),
-            contextToggle: result(raw.session.contextToggle),
-            create: result(raw.session.create),
-            delete: result(raw.session.remove),
-            diff: result(raw.session.diff),
-            fork: result(raw.session.fork),
-            get: result(raw.session.get),
-            goal: result(raw.session.goal),
-            instructions: result(raw.session.instructions),
-            list: resultAt(raw.session.list),
-            message: result(raw.session.message),
-            messages: result(raw.session.messages),
-            monitor: result(raw.session.monitor),
-            monitorCancel: result(raw.session.monitorCancel),
-            monitorLog: result(raw.session.monitorLog),
-            pending: result(raw.session.pending),
-            pendingSteer: result(raw.session.pendingSteer),
-            prompt: result(raw["session-prompt"].prompt),
-            promptAsync: result(raw["session-prompt"].promptAsync),
-            revert: result(raw.session.revert),
-            share: result(raw.session.share),
-            shell: result(raw.session.shell),
-            status: result0(raw.session.status),
-            summarize: result(raw.session.summarize),
-            todo: result(raw.session.todo),
-            unrevert: result(raw.session.unrevert),
-            unshare: result(raw.session.unshare),
-            update: result(raw.session.update),
-            v2: {
-                entries: result(raw.session.v2Entries),
-                events: result(raw.session.v2Events),
-                state: result(raw.session.v2State),
-            },
-        },
-        sync: {
-            config: {
-                set: result(raw.sync.config),
-            },
-            connect: result0(raw.sync.connect),
-            disconnect: result0(raw.sync.disconnect),
-            drain: result0(raw.sync.drain),
-            event: {
-                push: result(raw.sync.event),
-                stream: stream(raw.sync.stream),
-            },
-            outbox: {
-                list: result(raw.sync.outbox),
-            },
-            snapshot: {
-                get: result(raw.sync.snapshot),
-            },
-            stats: result(raw.sync.stats),
-        },
-        tool: {
-            ids: result0(raw.experimental.toolIDs),
-            list: result(raw.experimental.tools),
-        },
-        tui: {
-            appendPrompt: result(raw.tui.appendPrompt),
-            clearPrompt: result0(raw.tui.clearPrompt),
-            config: result0(raw.tui.config),
-            control: {
-                next: result0(raw.tui.controlNext),
-                response: result(raw.tui.controlResponse),
-            },
-            executeCommand: result(raw.tui.executeCommand),
-            openHelp: result0(raw.tui.openHelp),
-            openModels: result0(raw.tui.openModels),
-            openSessions: result0(raw.tui.openSessions),
-            openThemes: result0(raw.tui.openThemes),
-            publish: result(raw.tui.publish),
-            selectSession: result(raw.tui.selectSession),
-            showToast: result(raw.tui.showToast),
-            submitPrompt: result0(raw.tui.submitPrompt),
-        },
-        vcs: {
-            apply: result(raw["top-level"].vcsApply),
-            diff: {
-                raw: result0(raw["top-level"].vcsDiffRaw),
-            },
-            get: result0(raw["top-level"].vcs),
-            status: result0(raw["top-level"].vcsStatus),
-        },
-        worktree: {
-            create: result(raw.experimental.worktreeCreate),
-            list: result0(raw.experimental.worktree),
-            remove: resultAt(raw.experimental.worktreeRemove),
-            reset: resultAt(raw.experimental.worktreeReset),
-        },
-    };
+    return makeCompat(raw, helpers(defaults));
 }