@nikcli-ai/sdk 1.276.0 → 1.277.0

package/dist/httpapi/generated/client.js

@@ -559,1459 +559,1475 @@ export function make(options) {
                 empty: false,
             }, requestOptions),
         },
-        project: {
-            list: (requestOptions) => request({ method: "GET", path: `/project`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
-            current: (requestOptions) => request({ method: "GET", path: `/project/current`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
-            update: (input, requestOptions) => request({
-                method: "PATCH",
-                path: `/project/${encodeURIComponent(input.projectID)}`,
-                body: { name: input["name"], icon: input["icon"] },
+        mobile: {
+            authTokenList: (requestOptions) => request({ method: "GET", path: `/mobile/auth/token`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
+            authTokenCreate: (input, requestOptions) => request({
+                method: "POST",
+                path: `/mobile/auth/token`,
+                body: { name: input?.["name"], expiresInDays: input?.["expiresInDays"] },
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            directoryList: (input, requestOptions) => request({
-                method: "GET",
-                path: `/project/${encodeURIComponent(input.projectID)}/directory`,
+            authTokenRevoke: (input, requestOptions) => request({
+                method: "DELETE",
+                path: `/mobile/auth/token/${encodeURIComponent(input.id)}`,
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            copyCreate: (input, requestOptions) => request({
-                method: "POST",
-                path: `/project/${encodeURIComponent(input.projectID)}/copy`,
-                body: { strategy: input["strategy"], directory: input["directory"], name: input["name"] },
+            bootstrap: (requestOptions) => request({ method: "GET", path: `/mobile/bootstrap`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
+            commandList: (requestOptions) => request({ method: "GET", path: `/mobile/command`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
+            projectList: (requestOptions) => request({ method: "GET", path: `/mobile/project`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
+            memoryHistory: (requestOptions) => request({ method: "GET", path: `/mobile/memory/history`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
+            memorySearch: (input, requestOptions) => request({
+                method: "GET",
+                path: `/mobile/memory/search`,
+                query: { query: input["query"] },
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            copyRemove: (input, requestOptions) => request({
-                method: "DELETE",
-                path: `/project/${encodeURIComponent(input.projectID)}/copy`,
-                body: { directory: input["directory"], force: input["force"] },
-                successStatus: 204,
-                declaredStatuses: [],
-                empty: true,
-            }, requestOptions),
-            copyRefresh: (input, requestOptions) => request({
+            memoryStashList: (requestOptions) => request({ method: "GET", path: `/mobile/memory/stash`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
+            memoryStashCreate: (input, requestOptions) => request({
                 method: "POST",
-                path: `/project/${encodeURIComponent(input.projectID)}/copy/refresh`,
+                path: `/mobile/memory/stash`,
+                body: { input: input["input"] },
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-        },
-        provider: {
-            list: (requestOptions) => request({ method: "GET", path: `/provider`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
-            auth: (requestOptions) => request({ method: "GET", path: `/provider/auth`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
-            api: (input, requestOptions) => request({
-                method: "POST",
-                path: `/provider/${encodeURIComponent(input.providerID)}/api`,
-                body: { key: input["key"] },
+            memoryStashDelete: (input, requestOptions) => request({
+                method: "DELETE",
+                path: `/mobile/memory/stash/${encodeURIComponent(input.id)}`,
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            removeAuth: (input, requestOptions) => request({
-                method: "DELETE",
-                path: `/provider/${encodeURIComponent(input.providerID)}/auth`,
+            githubRepos: (requestOptions) => request({ method: "GET", path: `/mobile/github/repos`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
+            githubBranches: (input, requestOptions) => request({
+                method: "GET",
+                path: `/mobile/github/repos/${encodeURIComponent(input.owner)}/${encodeURIComponent(input.repo)}/branches`,
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            oauthAuthorize: (input, requestOptions) => request({
+            githubImports: (requestOptions) => request({ method: "GET", path: `/mobile/github/imports`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
+            githubOauthClient: (input, requestOptions) => request({
                 method: "POST",
-                path: `/provider/${encodeURIComponent(input.providerID)}/oauth/authorize`,
-                body: { method: input["method"] },
+                path: `/mobile/github/oauth/client`,
+                body: { clientId: input["clientId"] },
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            oauthCallback: (input, requestOptions) => request({
+            githubOauthDeviceStart: (requestOptions) => request({
                 method: "POST",
-                path: `/provider/${encodeURIComponent(input.providerID)}/oauth/callback`,
-                body: { method: input["method"], code: input["code"] },
+                path: `/mobile/github/oauth/device`,
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-        },
-        question: {
-            list: (requestOptions) => request({ method: "GET", path: `/question`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
-            reply: (input, requestOptions) => request({
+            githubOauthDevicePoll: (input, requestOptions) => request({
                 method: "POST",
-                path: `/question/${encodeURIComponent(input.requestID)}/reply`,
-                body: { answers: input["answers"] },
+                path: `/mobile/github/oauth/device/poll`,
+                body: { deviceCode: input["deviceCode"] },
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            reject: (input, requestOptions) => request({
+            githubAuthSet: (input, requestOptions) => request({
                 method: "POST",
-                path: `/question/${encodeURIComponent(input.requestID)}/reject`,
+                path: `/mobile/github/auth`,
+                body: { token: input["token"] },
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-        },
-        permission: {
-            list: (requestOptions) => request({ method: "GET", path: `/permission`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
-            reply: (input, requestOptions) => request({
+            githubAuthRemove: (requestOptions) => request({ method: "DELETE", path: `/mobile/github/auth`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
+            githubImport: (input, requestOptions) => request({
                 method: "POST",
-                path: `/permission/${encodeURIComponent(input.requestID)}/reply`,
-                body: { reply: input["reply"], message: input["message"] },
+                path: `/mobile/github/import`,
+                body: input["payload"],
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-        },
-        pty: {
-            list: (requestOptions) => request({ method: "GET", path: `/pty`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
-            create: (input, requestOptions) => request({
+            githubSessionCreate: (input, requestOptions) => request({
                 method: "POST",
-                path: `/pty`,
+                path: `/mobile/github/session`,
                 body: {
-                    command: input?.["command"],
-                    args: input?.["args"],
-                    cwd: input?.["cwd"],
-                    title: input?.["title"],
-                    env: input?.["env"],
+                    owner: input["owner"],
+                    repo: input["repo"],
+                    cloneUrl: input["cloneUrl"],
+                    htmlUrl: input["htmlUrl"],
+                    defaultBranch: input["defaultBranch"],
+                    baseBranch: input["baseBranch"],
+                    private: input["private"],
+                    title: input["title"],
+                    executionTarget: input["executionTarget"],
                 },
                 successStatus: 200,
-                declaredStatuses: [400],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            get: (input, requestOptions) => request({
+            sessionList: (input, requestOptions) => request({
                 method: "GET",
-                path: `/pty/${encodeURIComponent(input.ptyID)}`,
+                path: `/mobile/session`,
+                query: { limit: input?.["limit"], search: input?.["search"] },
                 successStatus: 200,
-                declaredStatuses: [404],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            update: (input, requestOptions) => request({
-                method: "PUT",
-                path: `/pty/${encodeURIComponent(input.ptyID)}`,
-                body: { title: input["title"], size: input["size"] },
+            sessionCreate: (input, requestOptions) => request({
+                method: "POST",
+                path: `/mobile/session`,
+                body: {
+                    parentID: input?.["parentID"],
+                    title: input?.["title"],
+                    permission: input?.["permission"],
+                    github: input?.["github"],
+                    executionTarget: input?.["executionTarget"],
+                },
                 successStatus: 200,
-                declaredStatuses: [404],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            remove: (input, requestOptions) => request({
-                method: "DELETE",
-                path: `/pty/${encodeURIComponent(input.ptyID)}`,
+            sessionDetail: (input, requestOptions) => request({
+                method: "GET",
+                path: `/mobile/session/${encodeURIComponent(input.sessionID)}`,
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-        },
-        loop: {
-            list: (requestOptions) => request({ method: "GET", path: `/loop`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
-            templates: (requestOptions) => request({ method: "GET", path: `/loop/templates`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
-            generate: (input, requestOptions) => request({
-                method: "POST",
-                path: `/loop/generate`,
-                body: { description: input["description"], model: input["model"], agent: input["agent"] },
+            sessionDelete: (input, requestOptions) => request({
+                method: "DELETE",
+                path: `/mobile/session/${encodeURIComponent(input.sessionID)}`,
                 successStatus: 200,
-                declaredStatuses: [400],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            recentRuns: (input, requestOptions) => request({
+            sessionDiff: (input, requestOptions) => request({
                 method: "GET",
-                path: `/loop/runs/recent`,
-                query: { limit: input?.["limit"] },
+                path: `/mobile/session/${encodeURIComponent(input.sessionID)}/diff/${encodeURIComponent(input.messageID)}`,
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            get: (input, requestOptions) => request({
+            sessionCommandList: (input, requestOptions) => request({
                 method: "GET",
-                path: `/loop/${encodeURIComponent(input.id)}`,
+                path: `/mobile/session/${encodeURIComponent(input.sessionID)}/command`,
                 successStatus: 200,
-                declaredStatuses: [404],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            upsert: (input, requestOptions) => request({
-                method: "PUT",
-                path: `/loop`,
-                body: input["payload"],
+            sessionCommand: (input, requestOptions) => request({
+                method: "POST",
+                path: `/mobile/session/${encodeURIComponent(input.sessionID)}/command`,
+                body: {
+                    command: input["command"],
+                    arguments: input["arguments"],
+                    agent: input["agent"],
+                    model: input["model"],
+                    variant: input["variant"],
+                },
                 successStatus: 200,
-                declaredStatuses: [400],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            update: (input, requestOptions) => request({
+            sessionMessage: (input, requestOptions) => request({
                 method: "POST",
-                path: `/loop/${encodeURIComponent(input.id)}`,
-                body: input["payload"],
+                path: `/mobile/session/${encodeURIComponent(input.sessionID)}/message`,
+                body: {
+                    messageID: input["messageID"],
+                    model: input["model"],
+                    agent: input["agent"],
+                    noReply: input["noReply"],
+                    tools: input["tools"],
+                    format: input["format"],
+                    system: input["system"],
+                    variant: input["variant"],
+                    parts: input["parts"],
+                },
                 successStatus: 200,
-                declaredStatuses: [404, 400],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            remove: (input, requestOptions) => request({
-                method: "DELETE",
-                path: `/loop/${encodeURIComponent(input.id)}`,
+            sessionAbort: (input, requestOptions) => request({
+                method: "POST",
+                path: `/mobile/session/${encodeURIComponent(input.sessionID)}/abort`,
                 successStatus: 200,
-                declaredStatuses: [404],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            toggle: (input, requestOptions) => request({
+            permissionRespond: (input, requestOptions) => request({
                 method: "POST",
-                path: `/loop/${encodeURIComponent(input.id)}/toggle`,
-                body: { enabled: input["enabled"] },
+                path: `/mobile/session/${encodeURIComponent(input.sessionID)}/permissions/${encodeURIComponent(input.permissionID)}`,
+                body: { response: input["response"] },
                 successStatus: 200,
-                declaredStatuses: [404],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            run: (input, requestOptions) => request({
+            questionRespond: (input, requestOptions) => request({
                 method: "POST",
-                path: `/loop/${encodeURIComponent(input.id)}/run`,
+                path: `/mobile/session/${encodeURIComponent(input.sessionID)}/question/${encodeURIComponent(input.requestID)}`,
+                body: { answers: input["answers"] },
                 successStatus: 200,
-                declaredStatuses: [404],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            abort: (input, requestOptions) => request({
-                method: "POST",
-                path: `/loop/${encodeURIComponent(input.id)}/abort`,
+            questionReject: (input, requestOptions) => request({
+                method: "DELETE",
+                path: `/mobile/session/${encodeURIComponent(input.sessionID)}/question/${encodeURIComponent(input.requestID)}`,
                 successStatus: 200,
-                declaredStatuses: [404],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            pause: (input, requestOptions) => request({
+            sessionPublish: (input, requestOptions) => request({
                 method: "POST",
-                path: `/loop/${encodeURIComponent(input.id)}/pause`,
+                path: `/mobile/session/${encodeURIComponent(input.sessionID)}/publish`,
+                body: { title: input["title"], body: input["body"], commitMessage: input["commitMessage"] },
                 successStatus: 200,
-                declaredStatuses: [404],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            resume: (input, requestOptions) => request({
+            sessionCleanup: (input, requestOptions) => request({
                 method: "POST",
-                path: `/loop/${encodeURIComponent(input.id)}/resume`,
+                path: `/mobile/session/${encodeURIComponent(input.sessionID)}/cleanup`,
                 successStatus: 200,
-                declaredStatuses: [404],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            runs: (input, requestOptions) => request({
+            sessionStream: (input, requestOptions) => sse({
                 method: "GET",
-                path: `/loop/${encodeURIComponent(input.id)}/runs`,
-                query: { limit: input["limit"] },
+                path: `/mobile/session/${encodeURIComponent(input.sessionID)}/stream`,
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-        },
-        session: {
-            list: (input, requestOptions) => request({
-                method: "GET",
-                path: `/session`,
-                query: {
-                    directory: input?.["directory"],
-                    roots: input?.["roots"],
-                    start: input?.["start"],
-                    search: input?.["search"],
-                    limit: input?.["limit"],
+            sessionRename: (input, requestOptions) => request({
+                method: "POST",
+                path: `/mobile/session/${encodeURIComponent(input.sessionID)}/rename`,
+                body: { title: input["title"] },
+                successStatus: 200,
+                declaredStatuses: [],
+                empty: false,
+            }, requestOptions),
+            teleportUploadBegin: (requestOptions) => request({ method: "POST", path: `/mobile/teleport/upload`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
+            teleportUploadChunk: (input, requestOptions) => request({
+                method: "POST",
+                path: `/mobile/teleport/upload/${encodeURIComponent(input.uploadID)}`,
+                successStatus: 200,
+                declaredStatuses: [],
+                empty: false,
+            }, requestOptions),
+            teleportIn: (input, requestOptions) => request({
+                method: "POST",
+                path: `/mobile/teleport`,
+                body: {
+                    title: input["title"],
+                    name: input["name"],
+                    origin: input["origin"],
+                    permission: input["permission"],
+                    messages: input["messages"],
+                    uploadID: input["uploadID"],
                 },
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            create: (input, requestOptions) => request({
+            teleportOut: (input, requestOptions) => request({
                 method: "POST",
-                path: `/session`,
+                path: `/mobile/session/${encodeURIComponent(input.sessionID)}/teleport`,
                 body: {
-                    parentID: input?.["parentID"],
-                    title: input?.["title"],
-                    permission: input?.["permission"],
-                    skills: input?.["skills"],
-                    github: input?.["github"],
-                    workspaceID: input?.["workspaceID"],
+                    url: input["url"],
+                    token: input["token"],
+                    content: input["content"],
+                    includeGit: input["includeGit"],
                 },
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            status: (requestOptions) => request({ method: "GET", path: `/session/status`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
-            get: (input, requestOptions) => request({
-                method: "GET",
-                path: `/session/${encodeURIComponent(input.sessionID)}`,
+            worktreeCreate: (input, requestOptions) => request({
+                method: "POST",
+                path: `/mobile/worktree`,
+                body: input["payload"],
                 successStatus: 200,
-                declaredStatuses: [404, 409],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            remove: (input, requestOptions) => request({
+            worktreeRemove: (input, requestOptions) => request({
                 method: "DELETE",
-                path: `/session/${encodeURIComponent(input.sessionID)}`,
+                path: `/mobile/worktree`,
+                body: input["payload"],
                 successStatus: 200,
-                declaredStatuses: [404, 409],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            update: (input, requestOptions) => request({
-                method: "PATCH",
-                path: `/session/${encodeURIComponent(input.sessionID)}`,
-                body: { title: input["title"], time: input["time"] },
+            worktreeReset: (input, requestOptions) => request({
+                method: "POST",
+                path: `/mobile/worktree/reset`,
+                body: input["payload"],
                 successStatus: 200,
-                declaredStatuses: [404, 409],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            fork: (input, requestOptions) => request({
-                method: "POST",
-                path: `/session/${encodeURIComponent(input.sessionID)}/fork`,
-                body: { messageID: input["messageID"] },
+            gitStatus: (requestOptions) => request({ method: "GET", path: `/mobile/git/status`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
+            gitDiff: (input, requestOptions) => request({
+                method: "GET",
+                path: `/mobile/git/diff`,
+                query: { file: input?.["file"], staged: input?.["staged"] },
                 successStatus: 200,
-                declaredStatuses: [404, 409],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            abort: (input, requestOptions) => request({
-                method: "POST",
-                path: `/session/${encodeURIComponent(input.sessionID)}/abort`,
+            gitCommits: (input, requestOptions) => request({
+                method: "GET",
+                path: `/mobile/git/commits`,
+                query: { limit: input?.["limit"] },
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            revert: (input, requestOptions) => request({
+            gitBranches: (requestOptions) => request({ method: "GET", path: `/mobile/git/branches`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
+            gitCommit: (input, requestOptions) => request({
                 method: "POST",
-                path: `/session/${encodeURIComponent(input.sessionID)}/revert`,
-                body: { messageID: input["messageID"], partID: input["partID"] },
+                path: `/mobile/git/commit`,
+                body: {
+                    message: input["message"],
+                    files: input["files"],
+                    amend: input["amend"],
+                    stagedOnly: input["stagedOnly"],
+                },
                 successStatus: 200,
-                declaredStatuses: [404, 409],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            unrevert: (input, requestOptions) => request({
+            gitCheckout: (input, requestOptions) => request({
                 method: "POST",
-                path: `/session/${encodeURIComponent(input.sessionID)}/unrevert`,
+                path: `/mobile/git/checkout`,
+                body: { branch: input["branch"], create: input["create"] },
                 successStatus: 200,
-                declaredStatuses: [404, 409],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            share: (input, requestOptions) => request({
+            gitStage: (input, requestOptions) => request({
                 method: "POST",
-                path: `/session/${encodeURIComponent(input.sessionID)}/share`,
+                path: `/mobile/git/stage`,
+                body: { files: input["files"] },
                 successStatus: 200,
-                declaredStatuses: [404, 409],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            unshare: (input, requestOptions) => request({
-                method: "DELETE",
-                path: `/session/${encodeURIComponent(input.sessionID)}/share`,
+            gitUnstage: (input, requestOptions) => request({
+                method: "POST",
+                path: `/mobile/git/unstage`,
+                body: { files: input["files"] },
                 successStatus: 200,
-                declaredStatuses: [404, 409],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            summarize: (input, requestOptions) => request({
+            gitDiscard: (input, requestOptions) => request({
                 method: "POST",
-                path: `/session/${encodeURIComponent(input.sessionID)}/summarize`,
-                body: { providerID: input["providerID"], modelID: input["modelID"], auto: input["auto"] },
+                path: `/mobile/git/discard`,
+                body: { files: input["files"] },
                 successStatus: 200,
-                declaredStatuses: [404, 409],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            command: (input, requestOptions) => request({
+            gitPush: (input, requestOptions) => request({
                 method: "POST",
-                path: `/session/${encodeURIComponent(input.sessionID)}/command`,
-                body: {
-                    messageID: input["messageID"],
-                    agent: input["agent"],
-                    model: input["model"],
-                    arguments: input["arguments"],
-                    command: input["command"],
-                    variant: input["variant"],
-                    parts: input["parts"],
-                },
+                path: `/mobile/git/push`,
+                query: { upstream: input?.["upstream"] },
                 successStatus: 200,
-                declaredStatuses: [404, 409],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            shell: (input, requestOptions) => request({
+            gitPull: (requestOptions) => request({ method: "POST", path: `/mobile/git/pull`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
+            loopList: (requestOptions) => request({ method: "GET", path: `/mobile/loops`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
+            loopCreate: (input, requestOptions) => request({
                 method: "POST",
-                path: `/session/${encodeURIComponent(input.sessionID)}/shell`,
-                body: { agent: input["agent"], model: input["model"], command: input["command"] },
+                path: `/mobile/loops`,
+                body: input["payload"],
                 successStatus: 200,
-                declaredStatuses: [404, 409],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            permissionRespond: (input, requestOptions) => request({
+            loopTemplates: (requestOptions) => request({ method: "GET", path: `/mobile/loops/templates`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
+            loopGenerate: (input, requestOptions) => request({
                 method: "POST",
-                path: `/session/${encodeURIComponent(input.sessionID)}/permissions/${encodeURIComponent(input.permissionID)}`,
-                body: { response: input["response"] },
+                path: `/mobile/loops/generate`,
+                body: { description: input["description"], model: input["model"] },
                 successStatus: 200,
-                declaredStatuses: [404, 409],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            children: (input, requestOptions) => request({
+            loopRunsRecent: (input, requestOptions) => request({
                 method: "GET",
-                path: `/session/${encodeURIComponent(input.sessionID)}/children`,
+                path: `/mobile/loops/runs/recent`,
+                query: { limit: input?.["limit"] },
                 successStatus: 200,
-                declaredStatuses: [404, 409],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            todo: (input, requestOptions) => request({
+            loopGet: (input, requestOptions) => request({
                 method: "GET",
-                path: `/session/${encodeURIComponent(input.sessionID)}/todo`,
+                path: `/mobile/loops/${encodeURIComponent(input.id)}`,
                 successStatus: 200,
-                declaredStatuses: [404, 409],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            diff: (input, requestOptions) => request({
-                method: "GET",
-                path: `/session/${encodeURIComponent(input.sessionID)}/diff`,
-                query: { messageID: input["messageID"] },
+            loopDelete: (input, requestOptions) => request({
+                method: "DELETE",
+                path: `/mobile/loops/${encodeURIComponent(input.id)}`,
                 successStatus: 200,
-                declaredStatuses: [404, 409],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            messages: (input, requestOptions) => request({
-                method: "GET",
-                path: `/session/${encodeURIComponent(input.sessionID)}/message`,
-                query: { limit: input["limit"] },
+            loopUpdate: (input, requestOptions) => request({
+                method: "PATCH",
+                path: `/mobile/loops/${encodeURIComponent(input.id)}`,
+                body: input["payload"],
                 successStatus: 200,
-                declaredStatuses: [404, 409],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            message: (input, requestOptions) => request({
+            loopRuns: (input, requestOptions) => request({
                 method: "GET",
-                path: `/session/${encodeURIComponent(input.sessionID)}/message/${encodeURIComponent(input.messageID)}`,
+                path: `/mobile/loops/${encodeURIComponent(input.id)}/runs`,
+                query: { limit: input["limit"] },
                 successStatus: 200,
-                declaredStatuses: [404, 409],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            messageRemove: (input, requestOptions) => request({
-                method: "DELETE",
-                path: `/session/${encodeURIComponent(input.sessionID)}/message/${encodeURIComponent(input.messageID)}`,
+            loopRun: (input, requestOptions) => request({
+                method: "POST",
+                path: `/mobile/loops/${encodeURIComponent(input.id)}/run`,
                 successStatus: 200,
-                declaredStatuses: [404, 409],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            partRemove: (input, requestOptions) => request({
-                method: "DELETE",
-                path: `/session/${encodeURIComponent(input.sessionID)}/message/${encodeURIComponent(input.messageID)}/part/${encodeURIComponent(input.partID)}`,
+            loopAbort: (input, requestOptions) => request({
+                method: "POST",
+                path: `/mobile/loops/${encodeURIComponent(input.id)}/abort`,
                 successStatus: 200,
-                declaredStatuses: [404, 409],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            v2Entries: (input, requestOptions) => request({
-                method: "GET",
-                path: `/session/${encodeURIComponent(input.sessionID)}/v2/entries`,
+            loopToggle: (input, requestOptions) => request({
+                method: "POST",
+                path: `/mobile/loops/${encodeURIComponent(input.id)}/toggle`,
+                body: { enabled: input["enabled"] },
                 successStatus: 200,
-                declaredStatuses: [404, 409],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            v2State: (input, requestOptions) => request({
-                method: "GET",
-                path: `/session/${encodeURIComponent(input.sessionID)}/v2/state`,
+            loopPause: (input, requestOptions) => request({
+                method: "POST",
+                path: `/mobile/loops/${encodeURIComponent(input.id)}/pause`,
                 successStatus: 200,
-                declaredStatuses: [404, 409],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            v2Events: (input, requestOptions) => request({
-                method: "GET",
-                path: `/session/${encodeURIComponent(input.sessionID)}/v2/events`,
+            loopResume: (input, requestOptions) => request({
+                method: "POST",
+                path: `/mobile/loops/${encodeURIComponent(input.id)}/resume`,
                 successStatus: 200,
-                declaredStatuses: [404, 409],
-                empty: false,
-            }, requestOptions),
-            instructions: (input, requestOptions) => request({
-                method: "GET",
-                path: `/session/${encodeURIComponent(input.sessionID)}/instructions`,
-                successStatus: 200,
-                declaredStatuses: [404, 409],
-                empty: false,
-            }, requestOptions),
-            contextBreakdown: (input, requestOptions) => request({
-                method: "GET",
-                path: `/session/${encodeURIComponent(input.sessionID)}/context`,
-                successStatus: 200,
-                declaredStatuses: [404, 409],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            contextToggle: (input, requestOptions) => request({
+            routineList: (requestOptions) => request({ method: "GET", path: `/mobile/routines`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
+            routineCreate: (input, requestOptions) => request({
                 method: "POST",
-                path: `/session/${encodeURIComponent(input.sessionID)}/context/toggle`,
-                body: { kind: input["kind"], key: input["key"], enabled: input["enabled"] },
-                successStatus: 200,
-                declaredStatuses: [404, 409],
-                empty: false,
-            }, requestOptions),
-            goal: (input, requestOptions) => request({
-                method: "GET",
-                path: `/session/${encodeURIComponent(input.sessionID)}/goal`,
+                path: `/mobile/routines`,
+                body: input["payload"],
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            background: (input, requestOptions) => request({
+            routineGet: (input, requestOptions) => request({
                 method: "GET",
-                path: `/session/${encodeURIComponent(input.sessionID)}/background`,
+                path: `/mobile/routines/${encodeURIComponent(input.id)}`,
                 successStatus: 200,
-                declaredStatuses: [404],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            backgroundInspect: (input, requestOptions) => request({
-                method: "GET",
-                path: `/session/${encodeURIComponent(input.sessionID)}/background/${encodeURIComponent(input.delegationID)}`,
+            routineDelete: (input, requestOptions) => request({
+                method: "DELETE",
+                path: `/mobile/routines/${encodeURIComponent(input.id)}`,
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            backgroundRead: (input, requestOptions) => request({
-                method: "GET",
-                path: `/session/${encodeURIComponent(input.sessionID)}/background/${encodeURIComponent(input.delegationID)}/read`,
+            routineUpdate: (input, requestOptions) => request({
+                method: "PATCH",
+                path: `/mobile/routines/${encodeURIComponent(input.id)}`,
+                body: input["payload"],
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            backgroundCancel: (input, requestOptions) => request({
+            routineRun: (input, requestOptions) => request({
                 method: "POST",
-                path: `/session/${encodeURIComponent(input.sessionID)}/background/${encodeURIComponent(input.delegationID)}/cancel`,
+                path: `/mobile/routines/${encodeURIComponent(input.id)}/run`,
+                body: { text: input["text"] },
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            monitor: (input, requestOptions) => request({
-                method: "GET",
-                path: `/session/${encodeURIComponent(input.sessionID)}/monitor/${encodeURIComponent(input.monitorID)}`,
-                successStatus: 200,
-                declaredStatuses: [404, 409],
-                empty: false,
-            }, requestOptions),
-            monitorLog: (input, requestOptions) => request({
-                method: "GET",
-                path: `/session/${encodeURIComponent(input.sessionID)}/monitor/${encodeURIComponent(input.monitorID)}/log`,
-                query: { lines: input["lines"] },
+            routinePause: (input, requestOptions) => request({
+                method: "POST",
+                path: `/mobile/routines/${encodeURIComponent(input.id)}/pause`,
                 successStatus: 200,
-                declaredStatuses: [404, 409],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            monitorCancel: (input, requestOptions) => request({
+            routineResume: (input, requestOptions) => request({
                 method: "POST",
-                path: `/session/${encodeURIComponent(input.sessionID)}/monitor/${encodeURIComponent(input.monitorID)}/cancel`,
+                path: `/mobile/routines/${encodeURIComponent(input.id)}/resume`,
                 successStatus: 200,
-                declaredStatuses: [404, 409],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-        },
-        tui: {
-            appendPrompt: (input, requestOptions) => request({
+            routineTrigger: (input, requestOptions) => request({
                 method: "POST",
-                path: `/tui/append-prompt`,
-                body: input["payload"],
+                path: `/mobile/routines/trigger/${encodeURIComponent(input.token)}`,
+                body: { text: input["text"] },
                 successStatus: 200,
-                declaredStatuses: [400],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            openHelp: (requestOptions) => request({ method: "POST", path: `/tui/open-help`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
-            openSessions: (requestOptions) => request({ method: "POST", path: `/tui/open-sessions`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
-            openThemes: (requestOptions) => request({ method: "POST", path: `/tui/open-themes`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
-            openModels: (requestOptions) => request({ method: "POST", path: `/tui/open-models`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
-            submitPrompt: (requestOptions) => request({ method: "POST", path: `/tui/submit-prompt`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
-            clearPrompt: (requestOptions) => request({ method: "POST", path: `/tui/clear-prompt`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
-            executeCommand: (input, requestOptions) => request({
+            ptyList: (requestOptions) => request({ method: "GET", path: `/mobile/pty`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
+            ptyCreate: (input, requestOptions) => request({
                 method: "POST",
-                path: `/tui/execute-command`,
-                body: input["payload"],
+                path: `/mobile/pty`,
+                body: {
+                    command: input?.["command"],
+                    args: input?.["args"],
+                    cwd: input?.["cwd"],
+                    title: input?.["title"],
+                    env: input?.["env"],
+                },
                 successStatus: 200,
-                declaredStatuses: [400],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            showToast: (input, requestOptions) => request({
-                method: "POST",
-                path: `/tui/show-toast`,
-                body: input["payload"],
+            ptyGet: (input, requestOptions) => request({
+                method: "GET",
+                path: `/mobile/pty/${encodeURIComponent(input.ptyID)}`,
                 successStatus: 200,
-                declaredStatuses: [400],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            publish: (input, requestOptions) => request({
-                method: "POST",
-                path: `/tui/publish`,
-                body: input["payload"],
+            ptyUpdate: (input, requestOptions) => request({
+                method: "PUT",
+                path: `/mobile/pty/${encodeURIComponent(input.ptyID)}`,
+                body: { title: input["title"], size: input["size"] },
                 successStatus: 200,
-                declaredStatuses: [400],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            selectSession: (input, requestOptions) => request({
-                method: "POST",
-                path: `/tui/select-session`,
-                body: input["payload"],
+            ptyRemove: (input, requestOptions) => request({
+                method: "DELETE",
+                path: `/mobile/pty/${encodeURIComponent(input.ptyID)}`,
                 successStatus: 200,
-                declaredStatuses: [400, 404],
+                declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            controlNext: (requestOptions) => request({ method: "GET", path: `/tui/control/next`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
-            controlResponse: (input, requestOptions) => request({
-                method: "POST",
-                path: `/tui/control/response`,
-                body: input["payload"],
+        },
+        project: {
+            list: (requestOptions) => request({ method: "GET", path: `/project`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
+            current: (requestOptions) => request({ method: "GET", path: `/project/current`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
+            update: (input, requestOptions) => request({
+                method: "PATCH",
+                path: `/project/${encodeURIComponent(input.projectID)}`,
+                body: { name: input["name"], icon: input["icon"] },
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-        },
-        workspace: {
-            adaptors: (requestOptions) => request({
+            directoryList: (input, requestOptions) => request({
                 method: "GET",
-                path: `/experimental/workspace/adaptor`,
+                path: `/project/${encodeURIComponent(input.projectID)}/directory`,
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            syncList: (requestOptions) => request({
+            copyCreate: (input, requestOptions) => request({
                 method: "POST",
-                path: `/experimental/workspace/sync-list`,
+                path: `/project/${encodeURIComponent(input.projectID)}/copy`,
+                body: { strategy: input["strategy"], directory: input["directory"], name: input["name"] },
+                successStatus: 200,
+                declaredStatuses: [],
+                empty: false,
+            }, requestOptions),
+            copyRemove: (input, requestOptions) => request({
+                method: "DELETE",
+                path: `/project/${encodeURIComponent(input.projectID)}/copy`,
+                body: { directory: input["directory"], force: input["force"] },
                 successStatus: 204,
                 declaredStatuses: [],
                 empty: true,
             }, requestOptions),
-            status: (requestOptions) => request({
-                method: "GET",
-                path: `/experimental/workspace/status`,
+            copyRefresh: (input, requestOptions) => request({
+                method: "POST",
+                path: `/project/${encodeURIComponent(input.projectID)}/copy/refresh`,
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            create: (input, requestOptions) => request({
+        },
+        provider: {
+            list: (requestOptions) => request({ method: "GET", path: `/provider`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
+            auth: (requestOptions) => request({ method: "GET", path: `/provider/auth`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
+            api: (input, requestOptions) => request({
                 method: "POST",
-                path: `/experimental/workspace/${encodeURIComponent(input.id)}`,
-                body: { branch: input["branch"], config: input["config"] },
+                path: `/provider/${encodeURIComponent(input.providerID)}/api`,
+                body: { key: input["key"] },
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            list: (requestOptions) => request({ method: "GET", path: `/experimental/workspace`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
-            remove: (input, requestOptions) => request({
+            removeAuth: (input, requestOptions) => request({
                 method: "DELETE",
-                path: `/experimental/workspace/${encodeURIComponent(input.id)}`,
+                path: `/provider/${encodeURIComponent(input.providerID)}/auth`,
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            restore: (input, requestOptions) => request({
+            oauthAuthorize: (input, requestOptions) => request({
                 method: "POST",
-                path: `/experimental/workspace/${encodeURIComponent(input.id)}/restore`,
-                query: { timeoutMs: input["timeoutMs"] },
+                path: `/provider/${encodeURIComponent(input.providerID)}/oauth/authorize`,
+                body: { method: input["method"] },
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            sessionRestore: (input, requestOptions) => request({
+            oauthCallback: (input, requestOptions) => request({
                 method: "POST",
-                path: `/experimental/workspace/${encodeURIComponent(input.id)}/session/${encodeURIComponent(input.sessionID)}/restore`,
-                query: { timeoutMs: input["timeoutMs"] },
+                path: `/provider/${encodeURIComponent(input.providerID)}/oauth/callback`,
+                body: { method: input["method"], code: input["code"] },
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            warp: (input, requestOptions) => request({
-                method: "POST",
-                path: `/experimental/workspace/warp`,
-                body: {
-                    id: input["id"],
-                    sessionID: input["sessionID"],
-                    copyChanges: input["copyChanges"],
-                    timeoutMs: input["timeoutMs"],
-                },
-                successStatus: 204,
-                declaredStatuses: [],
-                empty: true,
-            }, requestOptions),
         },
-        sync: {
-            event: (input, requestOptions) => request({
+        question: {
+            list: (requestOptions) => request({ method: "GET", path: `/question`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
+            reply: (input, requestOptions) => request({
                 method: "POST",
-                path: `/sync/event`,
-                body: { event: input["event"], projectID: input["projectID"] },
-                successStatus: 204,
-                declaredStatuses: [],
-                empty: true,
-            }, requestOptions),
-            outbox: (input, requestOptions) => request({
-                method: "GET",
-                path: `/sync/outbox`,
-                query: { projectID: input["projectID"], since: input["since"] },
-                successStatus: 200,
-                declaredStatuses: [],
-                empty: false,
-            }, requestOptions),
-            snapshot: (input, requestOptions) => request({
-                method: "GET",
-                path: `/sync/snapshot/${encodeURIComponent(input.aggregateID)}`,
-                query: { projectID: input["projectID"] },
+                path: `/question/${encodeURIComponent(input.requestID)}/reply`,
+                body: { answers: input["answers"] },
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            stream: (input, requestOptions) => sse({
-                method: "GET",
-                path: `/sync/stream`,
-                query: { projectID: input["projectID"], token: input["token"] },
+            reject: (input, requestOptions) => request({
+                method: "POST",
+                path: `/question/${encodeURIComponent(input.requestID)}/reject`,
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            stats: (input, requestOptions) => request({
-                method: "GET",
-                path: `/sync/stats`,
-                query: { projectID: input?.["projectID"] },
+        },
+        permission: {
+            list: (requestOptions) => request({ method: "GET", path: `/permission`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
+            reply: (input, requestOptions) => request({
+                method: "POST",
+                path: `/permission/${encodeURIComponent(input.requestID)}/reply`,
+                body: { reply: input["reply"], message: input["message"] },
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            config: (input, requestOptions) => request({
+        },
+        pty: {
+            list: (requestOptions) => request({ method: "GET", path: `/pty`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
+            create: (input, requestOptions) => request({
                 method: "POST",
-                path: `/sync/config`,
-                body: { url: input["url"], token: input["token"], autostart: input["autostart"] },
+                path: `/pty`,
+                body: {
+                    command: input?.["command"],
+                    args: input?.["args"],
+                    cwd: input?.["cwd"],
+                    title: input?.["title"],
+                    env: input?.["env"],
+                },
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [400],
+                empty: false,
+            }, requestOptions),
+            get: (input, requestOptions) => request({
+                method: "GET",
+                path: `/pty/${encodeURIComponent(input.ptyID)}`,
+                successStatus: 200,
+                declaredStatuses: [404],
+                empty: false,
+            }, requestOptions),
+            update: (input, requestOptions) => request({
+                method: "PUT",
+                path: `/pty/${encodeURIComponent(input.ptyID)}`,
+                body: { title: input["title"], size: input["size"] },
+                successStatus: 200,
+                declaredStatuses: [404],
                 empty: false,
             }, requestOptions),
-            connect: (requestOptions) => request({ method: "POST", path: `/sync/connect`, successStatus: 204, declaredStatuses: [], empty: true }, requestOptions),
-            disconnect: (requestOptions) => request({ method: "POST", path: `/sync/disconnect`, successStatus: 204, declaredStatuses: [], empty: true }, requestOptions),
-            drain: (requestOptions) => request({ method: "POST", path: `/sync/drain`, successStatus: 204, declaredStatuses: [], empty: true }, requestOptions),
-        },
-        auth: {
             remove: (input, requestOptions) => request({
                 method: "DELETE",
-                path: `/auth/${encodeURIComponent(input.providerID)}`,
+                path: `/pty/${encodeURIComponent(input.ptyID)}`,
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
         },
-        "config-management": {
-            reload: (requestOptions) => request({ method: "POST", path: `/config/reload`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
-            mcpAdd: (input, requestOptions) => request({
+        loop: {
+            list: (requestOptions) => request({ method: "GET", path: `/loop`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
+            templates: (requestOptions) => request({ method: "GET", path: `/loop/templates`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
+            generate: (input, requestOptions) => request({
                 method: "POST",
-                path: `/config/mcp`,
-                body: { name: input["name"], config: input["config"] },
+                path: `/loop/generate`,
+                body: { description: input["description"], model: input["model"], agent: input["agent"] },
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [400],
                 empty: false,
             }, requestOptions),
-            mcpUpdate: (input, requestOptions) => request({
-                method: "PATCH",
-                path: `/config/mcp/${encodeURIComponent(input.name)}`,
-                body: input["payload"],
+            recentRuns: (input, requestOptions) => request({
+                method: "GET",
+                path: `/loop/runs/recent`,
+                query: { limit: input?.["limit"] },
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            mcpRemove: (input, requestOptions) => request({
-                method: "DELETE",
-                path: `/config/mcp/${encodeURIComponent(input.name)}`,
+            get: (input, requestOptions) => request({
+                method: "GET",
+                path: `/loop/${encodeURIComponent(input.id)}`,
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [404],
                 empty: false,
             }, requestOptions),
-            profileCreate: (input, requestOptions) => request({
-                method: "POST",
-                path: `/config/profiles`,
-                body: { name: input["name"] },
+            upsert: (input, requestOptions) => request({
+                method: "PUT",
+                path: `/loop`,
+                body: input["payload"],
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [400],
                 empty: false,
             }, requestOptions),
-            profileActivate: (input, requestOptions) => request({
+            update: (input, requestOptions) => request({
                 method: "POST",
-                path: `/config/profiles/activate/${encodeURIComponent(input.name)}`,
+                path: `/loop/${encodeURIComponent(input.id)}`,
+                body: input["payload"],
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [404, 400],
                 empty: false,
             }, requestOptions),
-        },
-        "session-prompt": {
-            prompt: (input, requestOptions) => request({
+            remove: (input, requestOptions) => request({
+                method: "DELETE",
+                path: `/loop/${encodeURIComponent(input.id)}`,
+                successStatus: 200,
+                declaredStatuses: [404],
+                empty: false,
+            }, requestOptions),
+            toggle: (input, requestOptions) => request({
                 method: "POST",
-                path: `/session/${encodeURIComponent(input.sessionID)}/message`,
-                body: {
-                    messageID: input["messageID"],
-                    model: input["model"],
-                    agent: input["agent"],
-                    noReply: input["noReply"],
-                    tools: input["tools"],
-                    format: input["format"],
-                    system: input["system"],
-                    variant: input["variant"],
-                    parts: input["parts"],
-                },
+                path: `/loop/${encodeURIComponent(input.id)}/toggle`,
+                body: { enabled: input["enabled"] },
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [404],
                 empty: false,
             }, requestOptions),
-            promptAsync: (input, requestOptions) => request({
+            run: (input, requestOptions) => request({
                 method: "POST",
-                path: `/session/${encodeURIComponent(input.sessionID)}/prompt_async`,
-                body: {
-                    messageID: input["messageID"],
-                    model: input["model"],
-                    agent: input["agent"],
-                    noReply: input["noReply"],
-                    tools: input["tools"],
-                    format: input["format"],
-                    system: input["system"],
-                    variant: input["variant"],
-                    parts: input["parts"],
-                },
-                successStatus: 204,
-                declaredStatuses: [],
-                empty: true,
+                path: `/loop/${encodeURIComponent(input.id)}/run`,
+                successStatus: 200,
+                declaredStatuses: [404],
+                empty: false,
             }, requestOptions),
-        },
-        share: {
-            short: (input, requestOptions) => request({
-                method: "GET",
-                path: `/s/${encodeURIComponent(input.shareID)}`,
+            abort: (input, requestOptions) => request({
+                method: "POST",
+                path: `/loop/${encodeURIComponent(input.id)}/abort`,
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [404],
                 empty: false,
             }, requestOptions),
-            page: (input, requestOptions) => request({
-                method: "GET",
-                path: `/share/${encodeURIComponent(input.shareID)}`,
+            pause: (input, requestOptions) => request({
+                method: "POST",
+                path: `/loop/${encodeURIComponent(input.id)}/pause`,
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [404],
                 empty: false,
             }, requestOptions),
-            api: (input, requestOptions) => request({
-                method: "GET",
-                path: `/api/share/${encodeURIComponent(input.shareID)}`,
+            resume: (input, requestOptions) => request({
+                method: "POST",
+                path: `/loop/${encodeURIComponent(input.id)}/resume`,
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [404],
                 empty: false,
             }, requestOptions),
-            data: (input, requestOptions) => request({
+            runs: (input, requestOptions) => request({
                 method: "GET",
-                path: `/api/share/${encodeURIComponent(input.shareID)}/data`,
+                path: `/loop/${encodeURIComponent(input.id)}/runs`,
+                query: { limit: input["limit"] },
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
         },
-        events: {
-            subscribe: (requestOptions) => sse({ method: "GET", path: `/event`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
-            global: (requestOptions) => sse({ method: "GET", path: `/global/event`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
-        },
-        "workspace-extra": {
-            events: (input, requestOptions) => request({
+        session: {
+            list: (input, requestOptions) => request({
                 method: "GET",
-                path: `/experimental/workspace/${encodeURIComponent(input.id)}/events`,
-                query: { from: input["from"] },
+                path: `/session`,
+                query: {
+                    directory: input?.["directory"],
+                    roots: input?.["roots"],
+                    start: input?.["start"],
+                    search: input?.["search"],
+                    limit: input?.["limit"],
+                },
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            sessionWarp: (input, requestOptions) => request({
+            create: (input, requestOptions) => request({
                 method: "POST",
-                path: `/experimental/workspace/session/${encodeURIComponent(input.sessionID)}/warp`,
+                path: `/session`,
                 body: {
-                    workspaceID: input["workspaceID"],
-                    copyChanges: input["copyChanges"],
-                    timeoutMs: input["timeoutMs"],
+                    parentID: input?.["parentID"],
+                    title: input?.["title"],
+                    permission: input?.["permission"],
+                    skills: input?.["skills"],
+                    github: input?.["github"],
+                    workspaceID: input?.["workspaceID"],
                 },
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-        },
-        users: {
-            register: (input, requestOptions) => request({
-                method: "POST",
-                path: `/user/register`,
-                body: {
-                    username: input["username"],
-                    email: input["email"],
-                    password: input["password"],
-                    displayName: input["displayName"],
-                },
+            status: (requestOptions) => request({ method: "GET", path: `/session/status`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
+            get: (input, requestOptions) => request({
+                method: "GET",
+                path: `/session/${encodeURIComponent(input.sessionID)}`,
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [404, 409],
                 empty: false,
             }, requestOptions),
-            login: (input, requestOptions) => request({
-                method: "POST",
-                path: `/user/login`,
-                body: { email: input["email"], password: input["password"] },
+            remove: (input, requestOptions) => request({
+                method: "DELETE",
+                path: `/session/${encodeURIComponent(input.sessionID)}`,
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [404, 409],
                 empty: false,
             }, requestOptions),
             update: (input, requestOptions) => request({
                 method: "PATCH",
-                path: `/user/${encodeURIComponent(input.id)}`,
-                body: { displayName: input["displayName"], password: input["password"], role: input["role"] },
+                path: `/session/${encodeURIComponent(input.sessionID)}`,
+                body: { title: input["title"], time: input["time"] },
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [404, 409],
                 empty: false,
             }, requestOptions),
-        },
-        mobile: {
-            authTokenList: (requestOptions) => request({ method: "GET", path: `/mobile/auth/token`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
-            authTokenCreate: (input, requestOptions) => request({
+            fork: (input, requestOptions) => request({
                 method: "POST",
-                path: `/mobile/auth/token`,
-                body: { name: input?.["name"], expiresInDays: input?.["expiresInDays"] },
+                path: `/session/${encodeURIComponent(input.sessionID)}/fork`,
+                body: { messageID: input["messageID"] },
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [404, 409],
                 empty: false,
             }, requestOptions),
-            authTokenRevoke: (input, requestOptions) => request({
-                method: "DELETE",
-                path: `/mobile/auth/token/${encodeURIComponent(input.id)}`,
+            abort: (input, requestOptions) => request({
+                method: "POST",
+                path: `/session/${encodeURIComponent(input.sessionID)}/abort`,
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            bootstrap: (requestOptions) => request({ method: "GET", path: `/mobile/bootstrap`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
-            commandList: (requestOptions) => request({ method: "GET", path: `/mobile/command`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
-            projectList: (requestOptions) => request({ method: "GET", path: `/mobile/project`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
-            memoryHistory: (requestOptions) => request({ method: "GET", path: `/mobile/memory/history`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
-            memorySearch: (input, requestOptions) => request({
-                method: "GET",
-                path: `/mobile/memory/search`,
-                query: { query: input["query"] },
+            revert: (input, requestOptions) => request({
+                method: "POST",
+                path: `/session/${encodeURIComponent(input.sessionID)}/revert`,
+                body: { messageID: input["messageID"], partID: input["partID"] },
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [404, 409],
                 empty: false,
             }, requestOptions),
-            memoryStashList: (requestOptions) => request({ method: "GET", path: `/mobile/memory/stash`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
-            memoryStashCreate: (input, requestOptions) => request({
+            unrevert: (input, requestOptions) => request({
                 method: "POST",
-                path: `/mobile/memory/stash`,
-                body: { input: input["input"] },
+                path: `/session/${encodeURIComponent(input.sessionID)}/unrevert`,
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [404, 409],
                 empty: false,
             }, requestOptions),
-            memoryStashDelete: (input, requestOptions) => request({
-                method: "DELETE",
-                path: `/mobile/memory/stash/${encodeURIComponent(input.id)}`,
+            share: (input, requestOptions) => request({
+                method: "POST",
+                path: `/session/${encodeURIComponent(input.sessionID)}/share`,
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [404, 409],
                 empty: false,
             }, requestOptions),
-            githubRepos: (requestOptions) => request({ method: "GET", path: `/mobile/github/repos`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
-            githubBranches: (input, requestOptions) => request({
-                method: "GET",
-                path: `/mobile/github/repos/${encodeURIComponent(input.owner)}/${encodeURIComponent(input.repo)}/branches`,
+            unshare: (input, requestOptions) => request({
+                method: "DELETE",
+                path: `/session/${encodeURIComponent(input.sessionID)}/share`,
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [404, 409],
                 empty: false,
             }, requestOptions),
-            githubImports: (requestOptions) => request({ method: "GET", path: `/mobile/github/imports`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
-            githubOauthClient: (input, requestOptions) => request({
+            summarize: (input, requestOptions) => request({
                 method: "POST",
-                path: `/mobile/github/oauth/client`,
-                body: { clientId: input["clientId"] },
+                path: `/session/${encodeURIComponent(input.sessionID)}/summarize`,
+                body: { providerID: input["providerID"], modelID: input["modelID"], auto: input["auto"] },
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [404, 409],
                 empty: false,
             }, requestOptions),
-            githubOauthDeviceStart: (requestOptions) => request({
+            command: (input, requestOptions) => request({
                 method: "POST",
-                path: `/mobile/github/oauth/device`,
+                path: `/session/${encodeURIComponent(input.sessionID)}/command`,
+                body: {
+                    messageID: input["messageID"],
+                    agent: input["agent"],
+                    model: input["model"],
+                    arguments: input["arguments"],
+                    command: input["command"],
+                    variant: input["variant"],
+                    parts: input["parts"],
+                },
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [404, 409],
                 empty: false,
             }, requestOptions),
-            githubOauthDevicePoll: (input, requestOptions) => request({
+            shell: (input, requestOptions) => request({
                 method: "POST",
-                path: `/mobile/github/oauth/device/poll`,
-                body: { deviceCode: input["deviceCode"] },
+                path: `/session/${encodeURIComponent(input.sessionID)}/shell`,
+                body: { agent: input["agent"], model: input["model"], command: input["command"] },
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [404, 409],
                 empty: false,
             }, requestOptions),
-            githubAuthSet: (input, requestOptions) => request({
+            permissionRespond: (input, requestOptions) => request({
                 method: "POST",
-                path: `/mobile/github/auth`,
-                body: { token: input["token"] },
+                path: `/session/${encodeURIComponent(input.sessionID)}/permissions/${encodeURIComponent(input.permissionID)}`,
+                body: { response: input["response"] },
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [404, 409],
                 empty: false,
             }, requestOptions),
-            githubAuthRemove: (requestOptions) => request({ method: "DELETE", path: `/mobile/github/auth`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
-            githubImport: (input, requestOptions) => request({
-                method: "POST",
-                path: `/mobile/github/import`,
-                body: input["payload"],
+            children: (input, requestOptions) => request({
+                method: "GET",
+                path: `/session/${encodeURIComponent(input.sessionID)}/children`,
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [404, 409],
                 empty: false,
             }, requestOptions),
-            githubSessionCreate: (input, requestOptions) => request({
-                method: "POST",
-                path: `/mobile/github/session`,
-                body: {
-                    owner: input["owner"],
-                    repo: input["repo"],
-                    cloneUrl: input["cloneUrl"],
-                    htmlUrl: input["htmlUrl"],
-                    defaultBranch: input["defaultBranch"],
-                    baseBranch: input["baseBranch"],
-                    private: input["private"],
-                    title: input["title"],
-                    executionTarget: input["executionTarget"],
-                },
+            todo: (input, requestOptions) => request({
+                method: "GET",
+                path: `/session/${encodeURIComponent(input.sessionID)}/todo`,
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [404, 409],
                 empty: false,
             }, requestOptions),
-            sessionList: (input, requestOptions) => request({
+            diff: (input, requestOptions) => request({
                 method: "GET",
-                path: `/mobile/session`,
-                query: { limit: input?.["limit"], search: input?.["search"] },
+                path: `/session/${encodeURIComponent(input.sessionID)}/diff`,
+                query: { messageID: input["messageID"] },
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [404, 409],
+                empty: false,
+            }, requestOptions),
+            messages: (input, requestOptions) => request({
+                method: "GET",
+                path: `/session/${encodeURIComponent(input.sessionID)}/message`,
+                query: { limit: input["limit"] },
+                successStatus: 200,
+                declaredStatuses: [404, 409],
                 empty: false,
             }, requestOptions),
-            sessionCreate: (input, requestOptions) => request({
-                method: "POST",
-                path: `/mobile/session`,
-                body: {
-                    parentID: input?.["parentID"],
-                    title: input?.["title"],
-                    permission: input?.["permission"],
-                    github: input?.["github"],
-                    executionTarget: input?.["executionTarget"],
-                },
+            message: (input, requestOptions) => request({
+                method: "GET",
+                path: `/session/${encodeURIComponent(input.sessionID)}/message/${encodeURIComponent(input.messageID)}`,
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [404, 409],
                 empty: false,
             }, requestOptions),
-            sessionDetail: (input, requestOptions) => request({
-                method: "GET",
-                path: `/mobile/session/${encodeURIComponent(input.sessionID)}`,
+            messageRemove: (input, requestOptions) => request({
+                method: "DELETE",
+                path: `/session/${encodeURIComponent(input.sessionID)}/message/${encodeURIComponent(input.messageID)}`,
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [404, 409],
                 empty: false,
             }, requestOptions),
-            sessionDelete: (input, requestOptions) => request({
+            partRemove: (input, requestOptions) => request({
                 method: "DELETE",
-                path: `/mobile/session/${encodeURIComponent(input.sessionID)}`,
+                path: `/session/${encodeURIComponent(input.sessionID)}/message/${encodeURIComponent(input.messageID)}/part/${encodeURIComponent(input.partID)}`,
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [404, 409],
                 empty: false,
             }, requestOptions),
-            sessionDiff: (input, requestOptions) => request({
-                method: "GET",
-                path: `/mobile/session/${encodeURIComponent(input.sessionID)}/diff/${encodeURIComponent(input.messageID)}`,
+            partUpdate: (input, requestOptions) => request({
+                method: "PATCH",
+                path: `/session/${encodeURIComponent(input.sessionID)}/message/${encodeURIComponent(input.messageID)}/part/${encodeURIComponent(input.partID)}`,
+                body: input["payload"],
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [404, 409],
                 empty: false,
             }, requestOptions),
-            sessionCommandList: (input, requestOptions) => request({
+            v2Entries: (input, requestOptions) => request({
                 method: "GET",
-                path: `/mobile/session/${encodeURIComponent(input.sessionID)}/command`,
+                path: `/session/${encodeURIComponent(input.sessionID)}/v2/entries`,
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [404, 409],
                 empty: false,
             }, requestOptions),
-            sessionCommand: (input, requestOptions) => request({
-                method: "POST",
-                path: `/mobile/session/${encodeURIComponent(input.sessionID)}/command`,
-                body: {
-                    command: input["command"],
-                    arguments: input["arguments"],
-                    agent: input["agent"],
-                    model: input["model"],
-                    variant: input["variant"],
-                },
+            v2State: (input, requestOptions) => request({
+                method: "GET",
+                path: `/session/${encodeURIComponent(input.sessionID)}/v2/state`,
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [404, 409],
                 empty: false,
             }, requestOptions),
-            sessionMessage: (input, requestOptions) => request({
-                method: "POST",
-                path: `/mobile/session/${encodeURIComponent(input.sessionID)}/message`,
-                body: {
-                    messageID: input["messageID"],
-                    model: input["model"],
-                    agent: input["agent"],
-                    noReply: input["noReply"],
-                    tools: input["tools"],
-                    format: input["format"],
-                    system: input["system"],
-                    variant: input["variant"],
-                    parts: input["parts"],
-                },
+            v2Events: (input, requestOptions) => request({
+                method: "GET",
+                path: `/session/${encodeURIComponent(input.sessionID)}/v2/events`,
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [404, 409],
                 empty: false,
             }, requestOptions),
-            sessionAbort: (input, requestOptions) => request({
-                method: "POST",
-                path: `/mobile/session/${encodeURIComponent(input.sessionID)}/abort`,
+            instructions: (input, requestOptions) => request({
+                method: "GET",
+                path: `/session/${encodeURIComponent(input.sessionID)}/instructions`,
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [404, 409],
                 empty: false,
             }, requestOptions),
-            permissionRespond: (input, requestOptions) => request({
-                method: "POST",
-                path: `/mobile/session/${encodeURIComponent(input.sessionID)}/permissions/${encodeURIComponent(input.permissionID)}`,
-                body: { response: input["response"] },
+            contextBreakdown: (input, requestOptions) => request({
+                method: "GET",
+                path: `/session/${encodeURIComponent(input.sessionID)}/context`,
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [404, 409],
                 empty: false,
             }, requestOptions),
-            questionRespond: (input, requestOptions) => request({
+            contextToggle: (input, requestOptions) => request({
                 method: "POST",
-                path: `/mobile/session/${encodeURIComponent(input.sessionID)}/question/${encodeURIComponent(input.requestID)}`,
-                body: { answers: input["answers"] },
+                path: `/session/${encodeURIComponent(input.sessionID)}/context/toggle`,
+                body: { kind: input["kind"], key: input["key"], enabled: input["enabled"] },
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [404, 409],
                 empty: false,
             }, requestOptions),
-            questionReject: (input, requestOptions) => request({
-                method: "DELETE",
-                path: `/mobile/session/${encodeURIComponent(input.sessionID)}/question/${encodeURIComponent(input.requestID)}`,
+            goal: (input, requestOptions) => request({
+                method: "GET",
+                path: `/session/${encodeURIComponent(input.sessionID)}/goal`,
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            sessionPublish: (input, requestOptions) => request({
-                method: "POST",
-                path: `/mobile/session/${encodeURIComponent(input.sessionID)}/publish`,
-                body: { title: input["title"], body: input["body"], commitMessage: input["commitMessage"] },
+            background: (input, requestOptions) => request({
+                method: "GET",
+                path: `/session/${encodeURIComponent(input.sessionID)}/background`,
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [404],
                 empty: false,
             }, requestOptions),
-            sessionCleanup: (input, requestOptions) => request({
-                method: "POST",
-                path: `/mobile/session/${encodeURIComponent(input.sessionID)}/cleanup`,
+            backgroundInspect: (input, requestOptions) => request({
+                method: "GET",
+                path: `/session/${encodeURIComponent(input.sessionID)}/background/${encodeURIComponent(input.delegationID)}`,
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            sessionStream: (input, requestOptions) => sse({
+            backgroundRead: (input, requestOptions) => request({
                 method: "GET",
-                path: `/mobile/session/${encodeURIComponent(input.sessionID)}/stream`,
+                path: `/session/${encodeURIComponent(input.sessionID)}/background/${encodeURIComponent(input.delegationID)}/read`,
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            sessionRename: (input, requestOptions) => request({
+            backgroundCancel: (input, requestOptions) => request({
                 method: "POST",
-                path: `/mobile/session/${encodeURIComponent(input.sessionID)}/rename`,
-                body: { title: input["title"] },
+                path: `/session/${encodeURIComponent(input.sessionID)}/background/${encodeURIComponent(input.delegationID)}/cancel`,
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            teleportUploadBegin: (requestOptions) => request({ method: "POST", path: `/mobile/teleport/upload`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
-            teleportUploadChunk: (input, requestOptions) => request({
-                method: "POST",
-                path: `/mobile/teleport/upload/${encodeURIComponent(input.uploadID)}`,
+            monitor: (input, requestOptions) => request({
+                method: "GET",
+                path: `/session/${encodeURIComponent(input.sessionID)}/monitor/${encodeURIComponent(input.monitorID)}`,
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [404, 409],
                 empty: false,
             }, requestOptions),
-            teleportIn: (input, requestOptions) => request({
-                method: "POST",
-                path: `/mobile/teleport`,
-                body: {
-                    title: input["title"],
-                    name: input["name"],
-                    origin: input["origin"],
-                    permission: input["permission"],
-                    messages: input["messages"],
-                    uploadID: input["uploadID"],
-                },
+            monitorLog: (input, requestOptions) => request({
+                method: "GET",
+                path: `/session/${encodeURIComponent(input.sessionID)}/monitor/${encodeURIComponent(input.monitorID)}/log`,
+                query: { lines: input["lines"] },
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [404, 409],
                 empty: false,
             }, requestOptions),
-            teleportOut: (input, requestOptions) => request({
+            monitorCancel: (input, requestOptions) => request({
                 method: "POST",
-                path: `/mobile/session/${encodeURIComponent(input.sessionID)}/teleport`,
-                body: {
-                    url: input["url"],
-                    token: input["token"],
-                    content: input["content"],
-                    includeGit: input["includeGit"],
-                },
+                path: `/session/${encodeURIComponent(input.sessionID)}/monitor/${encodeURIComponent(input.monitorID)}/cancel`,
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [404, 409],
                 empty: false,
             }, requestOptions),
-            worktreeCreate: (input, requestOptions) => request({
+        },
+        sync: {
+            event: (input, requestOptions) => request({
                 method: "POST",
-                path: `/mobile/worktree`,
-                body: input["payload"],
-                successStatus: 200,
+                path: `/sync/event`,
+                body: { event: input["event"], projectID: input["projectID"] },
+                successStatus: 204,
                 declaredStatuses: [],
-                empty: false,
+                empty: true,
             }, requestOptions),
-            worktreeRemove: (input, requestOptions) => request({
-                method: "DELETE",
-                path: `/mobile/worktree`,
-                body: input["payload"],
+            outbox: (input, requestOptions) => request({
+                method: "GET",
+                path: `/sync/outbox`,
+                query: { projectID: input["projectID"], since: input["since"] },
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            worktreeReset: (input, requestOptions) => request({
-                method: "POST",
-                path: `/mobile/worktree/reset`,
-                body: input["payload"],
+            snapshot: (input, requestOptions) => request({
+                method: "GET",
+                path: `/sync/snapshot/${encodeURIComponent(input.aggregateID)}`,
+                query: { projectID: input["projectID"] },
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            gitStatus: (requestOptions) => request({ method: "GET", path: `/mobile/git/status`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
-            gitDiff: (input, requestOptions) => request({
+            stream: (input, requestOptions) => sse({
                 method: "GET",
-                path: `/mobile/git/diff`,
-                query: { file: input?.["file"], staged: input?.["staged"] },
+                path: `/sync/stream`,
+                query: { projectID: input["projectID"], token: input["token"] },
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            gitCommits: (input, requestOptions) => request({
+            stats: (input, requestOptions) => request({
                 method: "GET",
-                path: `/mobile/git/commits`,
-                query: { limit: input?.["limit"] },
+                path: `/sync/stats`,
+                query: { projectID: input?.["projectID"] },
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            gitBranches: (requestOptions) => request({ method: "GET", path: `/mobile/git/branches`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
-            gitCommit: (input, requestOptions) => request({
+            config: (input, requestOptions) => request({
                 method: "POST",
-                path: `/mobile/git/commit`,
-                body: {
-                    message: input["message"],
-                    files: input["files"],
-                    amend: input["amend"],
-                    stagedOnly: input["stagedOnly"],
-                },
+                path: `/sync/config`,
+                body: { url: input["url"], token: input["token"], autostart: input["autostart"] },
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            gitCheckout: (input, requestOptions) => request({
+            connect: (requestOptions) => request({ method: "POST", path: `/sync/connect`, successStatus: 204, declaredStatuses: [], empty: true }, requestOptions),
+            disconnect: (requestOptions) => request({ method: "POST", path: `/sync/disconnect`, successStatus: 204, declaredStatuses: [], empty: true }, requestOptions),
+            drain: (requestOptions) => request({ method: "POST", path: `/sync/drain`, successStatus: 204, declaredStatuses: [], empty: true }, requestOptions),
+        },
+        tui: {
+            appendPrompt: (input, requestOptions) => request({
                 method: "POST",
-                path: `/mobile/git/checkout`,
-                body: { branch: input["branch"], create: input["create"] },
+                path: `/tui/append-prompt`,
+                body: input["payload"],
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [400],
                 empty: false,
             }, requestOptions),
-            gitStage: (input, requestOptions) => request({
+            openHelp: (requestOptions) => request({ method: "POST", path: `/tui/open-help`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
+            openSessions: (requestOptions) => request({ method: "POST", path: `/tui/open-sessions`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
+            openThemes: (requestOptions) => request({ method: "POST", path: `/tui/open-themes`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
+            openModels: (requestOptions) => request({ method: "POST", path: `/tui/open-models`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
+            submitPrompt: (requestOptions) => request({ method: "POST", path: `/tui/submit-prompt`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
+            clearPrompt: (requestOptions) => request({ method: "POST", path: `/tui/clear-prompt`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
+            executeCommand: (input, requestOptions) => request({
                 method: "POST",
-                path: `/mobile/git/stage`,
-                body: { files: input["files"] },
+                path: `/tui/execute-command`,
+                body: input["payload"],
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [400],
                 empty: false,
             }, requestOptions),
-            gitUnstage: (input, requestOptions) => request({
+            showToast: (input, requestOptions) => request({
                 method: "POST",
-                path: `/mobile/git/unstage`,
-                body: { files: input["files"] },
+                path: `/tui/show-toast`,
+                body: input["payload"],
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [400],
                 empty: false,
             }, requestOptions),
-            gitDiscard: (input, requestOptions) => request({
+            publish: (input, requestOptions) => request({
                 method: "POST",
-                path: `/mobile/git/discard`,
-                body: { files: input["files"] },
+                path: `/tui/publish`,
+                body: input["payload"],
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [400],
                 empty: false,
             }, requestOptions),
-            gitPush: (input, requestOptions) => request({
+            selectSession: (input, requestOptions) => request({
                 method: "POST",
-                path: `/mobile/git/push`,
-                query: { upstream: input?.["upstream"] },
+                path: `/tui/select-session`,
+                body: input["payload"],
                 successStatus: 200,
-                declaredStatuses: [],
+                declaredStatuses: [400, 404],
                 empty: false,
             }, requestOptions),
-            gitPull: (requestOptions) => request({ method: "POST", path: `/mobile/git/pull`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
-            loopList: (requestOptions) => request({ method: "GET", path: `/mobile/loops`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
-            loopCreate: (input, requestOptions) => request({
+            controlNext: (requestOptions) => request({ method: "GET", path: `/tui/control/next`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
+            controlResponse: (input, requestOptions) => request({
                 method: "POST",
-                path: `/mobile/loops`,
+                path: `/tui/control/response`,
                 body: input["payload"],
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            loopTemplates: (requestOptions) => request({ method: "GET", path: `/mobile/loops/templates`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
-            loopGenerate: (input, requestOptions) => request({
-                method: "POST",
-                path: `/mobile/loops/generate`,
-                body: { description: input["description"], model: input["model"] },
+        },
+        workspace: {
+            adaptors: (requestOptions) => request({
+                method: "GET",
+                path: `/experimental/workspace/adaptor`,
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            loopRunsRecent: (input, requestOptions) => request({
+            syncList: (requestOptions) => request({
+                method: "POST",
+                path: `/experimental/workspace/sync-list`,
+                successStatus: 204,
+                declaredStatuses: [],
+                empty: true,
+            }, requestOptions),
+            status: (requestOptions) => request({
                 method: "GET",
-                path: `/mobile/loops/runs/recent`,
-                query: { limit: input?.["limit"] },
+                path: `/experimental/workspace/status`,
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            loopGet: (input, requestOptions) => request({
-                method: "GET",
-                path: `/mobile/loops/${encodeURIComponent(input.id)}`,
+            create: (input, requestOptions) => request({
+                method: "POST",
+                path: `/experimental/workspace/${encodeURIComponent(input.id)}`,
+                body: { branch: input["branch"], config: input["config"] },
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            loopDelete: (input, requestOptions) => request({
+            list: (requestOptions) => request({ method: "GET", path: `/experimental/workspace`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
+            remove: (input, requestOptions) => request({
                 method: "DELETE",
-                path: `/mobile/loops/${encodeURIComponent(input.id)}`,
+                path: `/experimental/workspace/${encodeURIComponent(input.id)}`,
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            loopUpdate: (input, requestOptions) => request({
-                method: "PATCH",
-                path: `/mobile/loops/${encodeURIComponent(input.id)}`,
-                body: input["payload"],
+            restore: (input, requestOptions) => request({
+                method: "POST",
+                path: `/experimental/workspace/${encodeURIComponent(input.id)}/restore`,
+                query: { timeoutMs: input["timeoutMs"] },
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            loopRuns: (input, requestOptions) => request({
-                method: "GET",
-                path: `/mobile/loops/${encodeURIComponent(input.id)}/runs`,
-                query: { limit: input["limit"] },
+            sessionRestore: (input, requestOptions) => request({
+                method: "POST",
+                path: `/experimental/workspace/${encodeURIComponent(input.id)}/session/${encodeURIComponent(input.sessionID)}/restore`,
+                query: { timeoutMs: input["timeoutMs"] },
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            loopRun: (input, requestOptions) => request({
+            warp: (input, requestOptions) => request({
                 method: "POST",
-                path: `/mobile/loops/${encodeURIComponent(input.id)}/run`,
+                path: `/experimental/workspace/warp`,
+                body: {
+                    id: input["id"],
+                    sessionID: input["sessionID"],
+                    copyChanges: input["copyChanges"],
+                    timeoutMs: input["timeoutMs"],
+                },
+                successStatus: 204,
+                declaredStatuses: [],
+                empty: true,
+            }, requestOptions),
+        },
+        auth: {
+            set: (input, requestOptions) => request({
+                method: "PUT",
+                path: `/auth/${encodeURIComponent(input.providerID)}`,
+                body: input["payload"],
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            loopAbort: (input, requestOptions) => request({
-                method: "POST",
-                path: `/mobile/loops/${encodeURIComponent(input.id)}/abort`,
+            remove: (input, requestOptions) => request({
+                method: "DELETE",
+                path: `/auth/${encodeURIComponent(input.providerID)}`,
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            loopToggle: (input, requestOptions) => request({
+        },
+        "config-management": {
+            reload: (requestOptions) => request({ method: "POST", path: `/config/reload`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
+            mcpAdd: (input, requestOptions) => request({
                 method: "POST",
-                path: `/mobile/loops/${encodeURIComponent(input.id)}/toggle`,
-                body: { enabled: input["enabled"] },
+                path: `/config/mcp`,
+                body: { name: input["name"], config: input["config"] },
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            loopPause: (input, requestOptions) => request({
-                method: "POST",
-                path: `/mobile/loops/${encodeURIComponent(input.id)}/pause`,
+            mcpUpdate: (input, requestOptions) => request({
+                method: "PATCH",
+                path: `/config/mcp/${encodeURIComponent(input.name)}`,
+                body: input["payload"],
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            loopResume: (input, requestOptions) => request({
-                method: "POST",
-                path: `/mobile/loops/${encodeURIComponent(input.id)}/resume`,
+            mcpRemove: (input, requestOptions) => request({
+                method: "DELETE",
+                path: `/config/mcp/${encodeURIComponent(input.name)}`,
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            routineList: (requestOptions) => request({ method: "GET", path: `/mobile/routines`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
-            routineCreate: (input, requestOptions) => request({
+            profileCreate: (input, requestOptions) => request({
                 method: "POST",
-                path: `/mobile/routines`,
-                body: input["payload"],
+                path: `/config/profiles`,
+                body: { name: input["name"] },
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            routineGet: (input, requestOptions) => request({
-                method: "GET",
-                path: `/mobile/routines/${encodeURIComponent(input.id)}`,
+            profileActivate: (input, requestOptions) => request({
+                method: "POST",
+                path: `/config/profiles/activate/${encodeURIComponent(input.name)}`,
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            routineDelete: (input, requestOptions) => request({
-                method: "DELETE",
-                path: `/mobile/routines/${encodeURIComponent(input.id)}`,
+        },
+        "session-prompt": {
+            prompt: (input, requestOptions) => request({
+                method: "POST",
+                path: `/session/${encodeURIComponent(input.sessionID)}/message`,
+                body: {
+                    messageID: input["messageID"],
+                    model: input["model"],
+                    agent: input["agent"],
+                    noReply: input["noReply"],
+                    tools: input["tools"],
+                    format: input["format"],
+                    system: input["system"],
+                    variant: input["variant"],
+                    parts: input["parts"],
+                },
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            routineUpdate: (input, requestOptions) => request({
-                method: "PATCH",
-                path: `/mobile/routines/${encodeURIComponent(input.id)}`,
-                body: input["payload"],
+            promptAsync: (input, requestOptions) => request({
+                method: "POST",
+                path: `/session/${encodeURIComponent(input.sessionID)}/prompt_async`,
+                body: {
+                    messageID: input["messageID"],
+                    model: input["model"],
+                    agent: input["agent"],
+                    noReply: input["noReply"],
+                    tools: input["tools"],
+                    format: input["format"],
+                    system: input["system"],
+                    variant: input["variant"],
+                    parts: input["parts"],
+                },
+                successStatus: 204,
+                declaredStatuses: [],
+                empty: true,
+            }, requestOptions),
+        },
+        share: {
+            short: (input, requestOptions) => request({
+                method: "GET",
+                path: `/s/${encodeURIComponent(input.shareID)}`,
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            routineRun: (input, requestOptions) => request({
-                method: "POST",
-                path: `/mobile/routines/${encodeURIComponent(input.id)}/run`,
-                body: { text: input["text"] },
+            page: (input, requestOptions) => request({
+                method: "GET",
+                path: `/share/${encodeURIComponent(input.shareID)}`,
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            routinePause: (input, requestOptions) => request({
-                method: "POST",
-                path: `/mobile/routines/${encodeURIComponent(input.id)}/pause`,
+            api: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/share/${encodeURIComponent(input.shareID)}`,
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            routineResume: (input, requestOptions) => request({
-                method: "POST",
-                path: `/mobile/routines/${encodeURIComponent(input.id)}/resume`,
+            data: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/share/${encodeURIComponent(input.shareID)}/data`,
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            routineTrigger: (input, requestOptions) => request({
-                method: "POST",
-                path: `/mobile/routines/trigger/${encodeURIComponent(input.token)}`,
-                body: { text: input["text"] },
+        },
+        events: {
+            subscribe: (requestOptions) => sse({ method: "GET", path: `/event`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
+            global: (requestOptions) => sse({ method: "GET", path: `/global/event`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
+        },
+        "workspace-extra": {
+            events: (input, requestOptions) => request({
+                method: "GET",
+                path: `/experimental/workspace/${encodeURIComponent(input.id)}/events`,
+                query: { from: input["from"] },
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            ptyList: (requestOptions) => request({ method: "GET", path: `/mobile/pty`, successStatus: 200, declaredStatuses: [], empty: false }, requestOptions),
-            ptyCreate: (input, requestOptions) => request({
+            sessionWarp: (input, requestOptions) => request({
                 method: "POST",
-                path: `/mobile/pty`,
+                path: `/experimental/workspace/session/${encodeURIComponent(input.sessionID)}/warp`,
                 body: {
-                    command: input?.["command"],
-                    args: input?.["args"],
-                    cwd: input?.["cwd"],
-                    title: input?.["title"],
-                    env: input?.["env"],
+                    workspaceID: input["workspaceID"],
+                    copyChanges: input["copyChanges"],
+                    timeoutMs: input["timeoutMs"],
                 },
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            ptyGet: (input, requestOptions) => request({
-                method: "GET",
-                path: `/mobile/pty/${encodeURIComponent(input.ptyID)}`,
+        },
+        users: {
+            register: (input, requestOptions) => request({
+                method: "POST",
+                path: `/user/register`,
+                body: {
+                    username: input["username"],
+                    email: input["email"],
+                    password: input["password"],
+                    displayName: input["displayName"],
+                },
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            ptyUpdate: (input, requestOptions) => request({
-                method: "PUT",
-                path: `/mobile/pty/${encodeURIComponent(input.ptyID)}`,
-                body: { title: input["title"], size: input["size"] },
+            login: (input, requestOptions) => request({
+                method: "POST",
+                path: `/user/login`,
+                body: { email: input["email"], password: input["password"] },
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,
             }, requestOptions),
-            ptyRemove: (input, requestOptions) => request({
-                method: "DELETE",
-                path: `/mobile/pty/${encodeURIComponent(input.ptyID)}`,
+            update: (input, requestOptions) => request({
+                method: "PATCH",
+                path: `/user/${encodeURIComponent(input.id)}`,
+                body: { displayName: input["displayName"], password: input["password"], role: input["role"] },
                 successStatus: 200,
                 declaredStatuses: [],
                 empty: false,