@xemahq/agent-session-api-client 0.1.2

package/dist/endpoints/sessions/sessions.js

@@ -0,0 +1,812 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sessionsControllerRemoveAttachment = exports.getSessionsControllerRemoveAttachmentUrl = exports.sessionsControllerListAttachments = exports.getSessionsControllerListAttachmentsUrl = exports.sessionsControllerAddAttachment = exports.getSessionsControllerAddAttachmentUrl = exports.sessionsControllerArchive = exports.getSessionsControllerArchiveUrl = exports.sessionsControllerCompact = exports.getSessionsControllerCompactUrl = exports.sessionsControllerResume = exports.getSessionsControllerResumeUrl = exports.sessionsControllerPause = exports.getSessionsControllerPauseUrl = exports.sessionsControllerUpdateKbMounts = exports.getSessionsControllerUpdateKbMountsUrl = exports.sessionsControllerListKbMounts = exports.getSessionsControllerListKbMountsUrl = exports.sessionsControllerChangeTools = exports.getSessionsControllerChangeToolsUrl = exports.sessionsControllerChangeModel = exports.getSessionsControllerChangeModelUrl = exports.sessionsControllerResyncDocument = exports.getSessionsControllerResyncDocumentUrl = exports.sessionsControllerPushDocumentEdit = exports.getSessionsControllerPushDocumentEditUrl = exports.sessionsControllerReadFile = exports.getSessionsControllerReadFileUrl = exports.sessionsControllerListFiles = exports.getSessionsControllerListFilesUrl = exports.sessionsControllerStreamEvents = exports.getSessionsControllerStreamEventsUrl = exports.sessionsControllerRejectQuestion = exports.getSessionsControllerRejectQuestionUrl = exports.sessionsControllerReplyToQuestion = exports.getSessionsControllerReplyToQuestionUrl = exports.sessionsControllerTerminateByPipelineRunId = exports.getSessionsControllerTerminateByPipelineRunIdUrl = exports.sessionsControllerGetLockfile = exports.getSessionsControllerGetLockfileUrl = exports.sessionsControllerTerminate = exports.getSessionsControllerTerminateUrl = exports.sessionsControllerGetById = exports.getSessionsControllerGetByIdUrl = exports.sessionsControllerFork = exports.getSessionsControllerForkUrl = exports.sessionsControllerList = exports.getSessionsControllerListUrl = exports.sessionsControllerCreate = exports.getSessionsControllerCreateUrl = void 0;
+exports.buildImageControllerStatus = exports.getBuildImageControllerStatusUrl = exports.buildImageControllerStart = exports.getBuildImageControllerStartUrl = exports.sessionsControllerCreateShare = exports.getSessionsControllerCreateShareUrl = exports.sessionsControllerCloneTemplate = exports.getSessionsControllerCloneTemplateUrl = exports.sessionsControllerDeleteTemplate = exports.getSessionsControllerDeleteTemplateUrl = exports.sessionsControllerUpdateTemplate = exports.getSessionsControllerUpdateTemplateUrl = exports.sessionsControllerGetTemplate = exports.getSessionsControllerGetTemplateUrl = exports.sessionsControllerListTemplates = exports.getSessionsControllerListTemplatesUrl = exports.sessionsControllerCreateTemplate = exports.getSessionsControllerCreateTemplateUrl = exports.sessionsControllerPushToKB = exports.getSessionsControllerPushToKBUrl = exports.sessionsControllerMergeCheck = exports.getSessionsControllerMergeCheckUrl = exports.sessionsControllerGetCommitHistory = exports.getSessionsControllerGetCommitHistoryUrl = exports.sessionsControllerCreatePullRequest = exports.getSessionsControllerCreatePullRequestUrl = exports.sessionsControllerGitPush = exports.getSessionsControllerGitPushUrl = exports.sessionsControllerGitCommit = exports.getSessionsControllerGitCommitUrl = exports.sessionsControllerGetGitDiff = exports.getSessionsControllerGetGitDiffUrl = exports.sessionsControllerGetGitStatus = exports.getSessionsControllerGetGitStatusUrl = exports.sessionsControllerCreateBranch = exports.getSessionsControllerCreateBranchUrl = exports.sessionsControllerGetToolUsage = exports.getSessionsControllerGetToolUsageUrl = exports.sessionsControllerGetUsage = exports.getSessionsControllerGetUsageUrl = exports.sessionsControllerCompleteAttachmentUpload = exports.getSessionsControllerCompleteAttachmentUploadUrl = exports.sessionsControllerInitAttachmentUpload = exports.getSessionsControllerInitAttachmentUploadUrl = void 0;
+const custom_fetch_1 = require("../../custom-fetch");
+/**
+ * @summary Create a new agent session
+ */
+const getSessionsControllerCreateUrl = () => {
+    return `/sessions`;
+};
+exports.getSessionsControllerCreateUrl = getSessionsControllerCreateUrl;
+const sessionsControllerCreate = async (options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerCreateUrl)(), {
+        ...options,
+        method: 'POST'
+    });
+};
+exports.sessionsControllerCreate = sessionsControllerCreate;
+/**
+ * @summary List sessions with pagination and filters
+ */
+const getSessionsControllerListUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value === undefined)
+            return;
+        if (value === null) {
+            normalizedParams.append(key, 'null');
+            return;
+        }
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                if (item === undefined || item === null)
+                    continue;
+                normalizedParams.append(key, item.toString());
+            }
+            return;
+        }
+        normalizedParams.append(key, value.toString());
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0 ? `/sessions?${stringifiedParams}` : `/sessions`;
+};
+exports.getSessionsControllerListUrl = getSessionsControllerListUrl;
+const sessionsControllerList = async (params, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerListUrl)(params), {
+        ...options,
+        method: 'GET'
+    });
+};
+exports.sessionsControllerList = sessionsControllerList;
+/**
+ * @summary Fork an existing session. Creates a new session that inherits the parent's profile, model, repository and branch strategy, then provisions a fresh worker — no chat history is copied. Use this to explore a parallel direction without disturbing the parent.
+ */
+const getSessionsControllerForkUrl = (id) => {
+    return `/sessions/${id}/fork`;
+};
+exports.getSessionsControllerForkUrl = getSessionsControllerForkUrl;
+const sessionsControllerFork = async (id, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerForkUrl)(id), {
+        ...options,
+        method: 'POST'
+    });
+};
+exports.sessionsControllerFork = sessionsControllerFork;
+/**
+ * @summary Get session detail
+ */
+const getSessionsControllerGetByIdUrl = (id) => {
+    return `/sessions/${id}`;
+};
+exports.getSessionsControllerGetByIdUrl = getSessionsControllerGetByIdUrl;
+const sessionsControllerGetById = async (id, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerGetByIdUrl)(id), {
+        ...options,
+        method: 'GET'
+    });
+};
+exports.sessionsControllerGetById = sessionsControllerGetById;
+/**
+ * @summary Terminate and archive a session
+ */
+const getSessionsControllerTerminateUrl = (id) => {
+    return `/sessions/${id}`;
+};
+exports.getSessionsControllerTerminateUrl = getSessionsControllerTerminateUrl;
+const sessionsControllerTerminate = async (id, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerTerminateUrl)(id), {
+        ...options,
+        method: 'DELETE'
+    });
+};
+exports.sessionsControllerTerminate = sessionsControllerTerminate;
+/**
+ * @summary Get the pinned AppLockfile minted at session create time (plan §10.4 / §17.9 item 3). Returns 404 for sessions created before the lockfile column was introduced.
+ */
+const getSessionsControllerGetLockfileUrl = (id) => {
+    return `/sessions/${id}/lockfile`;
+};
+exports.getSessionsControllerGetLockfileUrl = getSessionsControllerGetLockfileUrl;
+const sessionsControllerGetLockfile = async (id, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerGetLockfileUrl)(id), {
+        ...options,
+        method: 'GET'
+    });
+};
+exports.sessionsControllerGetLockfile = sessionsControllerGetLockfile;
+/**
+ * @summary Terminate all non-terminal sessions tied to a pipeline run. Intended for service-to-service calls (e.g. work-orchestrator stopPipeline) that need to release OpenCode workers held by agent sessions spawned inside a run the user has just halted.
+ */
+const getSessionsControllerTerminateByPipelineRunIdUrl = (pipelineRunId) => {
+    return `/sessions/terminate-by-pipeline-run/${pipelineRunId}`;
+};
+exports.getSessionsControllerTerminateByPipelineRunIdUrl = getSessionsControllerTerminateByPipelineRunIdUrl;
+const sessionsControllerTerminateByPipelineRunId = async (pipelineRunId, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerTerminateByPipelineRunIdUrl)(pipelineRunId), {
+        ...options,
+        method: 'POST'
+    });
+};
+exports.sessionsControllerTerminateByPipelineRunId = sessionsControllerTerminateByPipelineRunId;
+/**
+ * @summary Reply to a question posed by the agent during a turn
+ */
+const getSessionsControllerReplyToQuestionUrl = (id, requestId) => {
+    return `/sessions/${id}/question/${requestId}/reply`;
+};
+exports.getSessionsControllerReplyToQuestionUrl = getSessionsControllerReplyToQuestionUrl;
+const sessionsControllerReplyToQuestion = async (id, requestId, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerReplyToQuestionUrl)(id, requestId), {
+        ...options,
+        method: 'POST'
+    });
+};
+exports.sessionsControllerReplyToQuestion = sessionsControllerReplyToQuestion;
+/**
+ * @summary Reject/dismiss a question posed by the agent during a turn
+ */
+const getSessionsControllerRejectQuestionUrl = (id, requestId) => {
+    return `/sessions/${id}/question/${requestId}/reject`;
+};
+exports.getSessionsControllerRejectQuestionUrl = getSessionsControllerRejectQuestionUrl;
+const sessionsControllerRejectQuestion = async (id, requestId, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerRejectQuestionUrl)(id, requestId), {
+        ...options,
+        method: 'POST'
+    });
+};
+exports.sessionsControllerRejectQuestion = sessionsControllerRejectQuestion;
+/**
+ * @summary Live SSE stream of session events — backlog from afterSequence, then live tail. Same wire shape as /timeline; reuse a single mapper on the FE.
+ */
+const getSessionsControllerStreamEventsUrl = (id, params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value === undefined)
+            return;
+        if (value === null) {
+            normalizedParams.append(key, 'null');
+            return;
+        }
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                if (item === undefined || item === null)
+                    continue;
+                normalizedParams.append(key, item.toString());
+            }
+            return;
+        }
+        normalizedParams.append(key, value.toString());
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0 ? `/sessions/${id}/events/stream?${stringifiedParams}` : `/sessions/${id}/events/stream`;
+};
+exports.getSessionsControllerStreamEventsUrl = getSessionsControllerStreamEventsUrl;
+const sessionsControllerStreamEvents = async (id, params, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerStreamEventsUrl)(id, params), {
+        ...options,
+        method: 'GET'
+    });
+};
+exports.sessionsControllerStreamEvents = sessionsControllerStreamEvents;
+/**
+ * @summary Browse workspace file tree (scoped proxy with security boundary)
+ */
+const getSessionsControllerListFilesUrl = (id, params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value === undefined)
+            return;
+        if (value === null) {
+            normalizedParams.append(key, 'null');
+            return;
+        }
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                if (item === undefined || item === null)
+                    continue;
+                normalizedParams.append(key, item.toString());
+            }
+            return;
+        }
+        normalizedParams.append(key, value.toString());
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0 ? `/sessions/${id}/files?${stringifiedParams}` : `/sessions/${id}/files`;
+};
+exports.getSessionsControllerListFilesUrl = getSessionsControllerListFilesUrl;
+const sessionsControllerListFiles = async (id, params, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerListFilesUrl)(id, params), {
+        ...options,
+        method: 'GET'
+    });
+};
+exports.sessionsControllerListFiles = sessionsControllerListFiles;
+/**
+ * @summary Read file content from workspace (scoped proxy, deny list enforced, 1MB limit)
+ */
+const getSessionsControllerReadFileUrl = (id, filePath) => {
+    return `/sessions/${id}/files/${filePath}`;
+};
+exports.getSessionsControllerReadFileUrl = getSessionsControllerReadFileUrl;
+const sessionsControllerReadFile = async (id, filePath, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerReadFileUrl)(id, filePath), {
+        ...options,
+        method: 'GET'
+    });
+};
+exports.sessionsControllerReadFile = sessionsControllerReadFile;
+/**
+ * @summary Document Buddy up-channel — stream a user editor edit into the document working file. The new base content is 3-way merged against the agent's working copy: the user edit folds into the accepted base, non-colliding agent suggestions survive, and agent hunks on the same lines are marked STALE (the user always wins). No turn gate.
+ */
+const getSessionsControllerPushDocumentEditUrl = (id) => {
+    return `/sessions/${id}/document-edit`;
+};
+exports.getSessionsControllerPushDocumentEditUrl = getSessionsControllerPushDocumentEditUrl;
+const sessionsControllerPushDocumentEdit = async (id, pushDocumentEditDto, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerPushDocumentEditUrl)(id), {
+        ...options,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(pushDocumentEditDto)
+    });
+};
+exports.sessionsControllerPushDocumentEdit = sessionsControllerPushDocumentEdit;
+/**
+ * @summary Document Buddy — re-materialize the worker's document working file from knowledge-base-api after a patch decision (accept / reject). The frontend calls this best-effort once a decision succeeds so a discarded hunk's text actually leaves the worker file. A paused session returns `resynced: false` — its file re-materializes on resume.
+ */
+const getSessionsControllerResyncDocumentUrl = (id) => {
+    return `/sessions/${id}/document-resync`;
+};
+exports.getSessionsControllerResyncDocumentUrl = getSessionsControllerResyncDocumentUrl;
+const sessionsControllerResyncDocument = async (id, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerResyncDocumentUrl)(id), {
+        ...options,
+        method: 'POST'
+    });
+};
+exports.sessionsControllerResyncDocument = sessionsControllerResyncDocument;
+/**
+ * @summary Switch a session's model/provider override. Picks up on the NEXT user message — no worker restart. Send `selection: null` to clear the override and fall back to the agent's default modelClass strategy. Rejected for terminal sessions (completed/failed/archived).
+ */
+const getSessionsControllerChangeModelUrl = (id) => {
+    return `/sessions/${id}/model`;
+};
+exports.getSessionsControllerChangeModelUrl = getSessionsControllerChangeModelUrl;
+const sessionsControllerChangeModel = async (id, changeSessionModelDto, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerChangeModelUrl)(id), {
+        ...options,
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(changeSessionModelDto)
+    });
+};
+exports.sessionsControllerChangeModel = sessionsControllerChangeModel;
+/**
+ * @summary Replace a session's MCP tool selection. Takes a flat list of ToolSelectionEntry (provider-kind references + optional toolName for narrow selections). Each entry is tenancy-validated against the session's (orgId, projectId) BEFORE the column is written; cross-org references fail with 403. Phase D: applies HOT — the resolved `mcpServers` map is merged into the recomposed opencode.jsonc and pushed via `PUT /control/session-bundle`, triggering one opencode restart per real change (no restart when the fingerprint matches). Returns 409 `session_busy` when the session has an in-flight turn — wait for the agent to finish and retry. Default selection is `[]` (OpenCode built-ins only baseline).
+ */
+const getSessionsControllerChangeToolsUrl = (id) => {
+    return `/sessions/${id}/tools`;
+};
+exports.getSessionsControllerChangeToolsUrl = getSessionsControllerChangeToolsUrl;
+const sessionsControllerChangeTools = async (id, changeSessionToolsDto, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerChangeToolsUrl)(id), {
+        ...options,
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(changeSessionToolsDto)
+    });
+};
+exports.sessionsControllerChangeTools = sessionsControllerChangeTools;
+/**
+ * @summary List the KB spaces and per-space page selections currently mounted into this session's `/workspace/references/kb/` tree. Empty arrays on a session that has never set a selection.
+ */
+const getSessionsControllerListKbMountsUrl = (id) => {
+    return `/sessions/${id}/kb-mounts`;
+};
+exports.getSessionsControllerListKbMountsUrl = getSessionsControllerListKbMountsUrl;
+const sessionsControllerListKbMounts = async (id, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerListKbMountsUrl)(id), {
+        ...options,
+        method: 'GET'
+    });
+};
+exports.sessionsControllerListKbMounts = sessionsControllerListKbMounts;
+/**
+ * @summary Full-replace the session’s KB mount selection. Both `spaceIds` and `pageMounts` are total sets — the persisted selection is overwritten. If the session has a live worker, the workspace references slot is atomically re-applied so the agent sees the change on its next turn. If the session is paused, the change is persisted and materialized on the next resume. To clear all KB mounts, send `{ spaceIds: [], pageMounts: [] }`.
+ */
+const getSessionsControllerUpdateKbMountsUrl = (id) => {
+    return `/sessions/${id}/kb-mounts`;
+};
+exports.getSessionsControllerUpdateKbMountsUrl = getSessionsControllerUpdateKbMountsUrl;
+const sessionsControllerUpdateKbMounts = async (id, updateKbMountsDto, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerUpdateKbMountsUrl)(id), {
+        ...options,
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(updateKbMountsDto)
+    });
+};
+exports.sessionsControllerUpdateKbMounts = sessionsControllerUpdateKbMounts;
+/**
+ * @summary Pause session — snapshot to MinIO, release worker. Requires turnState=idle.
+ */
+const getSessionsControllerPauseUrl = (id) => {
+    return `/sessions/${id}/pause`;
+};
+exports.getSessionsControllerPauseUrl = getSessionsControllerPauseUrl;
+const sessionsControllerPause = async (id, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerPauseUrl)(id), {
+        ...options,
+        method: 'POST'
+    });
+};
+exports.sessionsControllerPause = sessionsControllerPause;
+/**
+ * @summary Resume paused session — acquire worker, restore snapshot. Pass `agentSlugOverride` to recover a session whose primary agent was removed.
+ */
+const getSessionsControllerResumeUrl = (id) => {
+    return `/sessions/${id}/resume`;
+};
+exports.getSessionsControllerResumeUrl = getSessionsControllerResumeUrl;
+const sessionsControllerResume = async (id, resumeSessionDto, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerResumeUrl)(id), {
+        ...options,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(resumeSessionDto)
+    });
+};
+exports.sessionsControllerResume = sessionsControllerResume;
+/**
+ * @summary Trigger OpenCode-native conversation compaction. Auto-resumes paused sessions. The summary lands as a new assistant message inside OpenCode and `session.compacted` fires, which the event-bridge relays — `Session.contextWindowSnapshot` is reset to zeros and the FE chip drops via SSE without polling. Auto-compact still runs inside OpenCode on overflow independently of this endpoint.
+ */
+const getSessionsControllerCompactUrl = (id) => {
+    return `/sessions/${id}/compact`;
+};
+exports.getSessionsControllerCompactUrl = getSessionsControllerCompactUrl;
+const sessionsControllerCompact = async (id, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerCompactUrl)(id), {
+        ...options,
+        method: 'POST'
+    });
+};
+exports.sessionsControllerCompact = sessionsControllerCompact;
+/**
+ * @summary Archive session — deletes the MinIO snapshot and the `xema/session/<id>` branches on each DELIVERABLE repo, releases any active worker, and transitions the row to status=archived. Idempotent: a call against an already-archived session returns the prior archivedAt without re-running cleanup. Distinct from `/pause`: pause preserves state for resume; archive throws it away.
+ */
+const getSessionsControllerArchiveUrl = (id) => {
+    return `/sessions/${id}/archive`;
+};
+exports.getSessionsControllerArchiveUrl = getSessionsControllerArchiveUrl;
+const sessionsControllerArchive = async (id, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerArchiveUrl)(id), {
+        ...options,
+        method: 'POST'
+    });
+};
+exports.sessionsControllerArchive = sessionsControllerArchive;
+/**
+ * @summary Add reference-class attachment to session (kb_page / org_document / internal_url / repo_ref)
+ */
+const getSessionsControllerAddAttachmentUrl = (id) => {
+    return `/sessions/${id}/attachments`;
+};
+exports.getSessionsControllerAddAttachmentUrl = getSessionsControllerAddAttachmentUrl;
+const sessionsControllerAddAttachment = async (id, addAttachmentDto, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerAddAttachmentUrl)(id), {
+        ...options,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(addAttachmentDto)
+    });
+};
+exports.sessionsControllerAddAttachment = sessionsControllerAddAttachment;
+/**
+ * @summary List session attachments
+ */
+const getSessionsControllerListAttachmentsUrl = (id) => {
+    return `/sessions/${id}/attachments`;
+};
+exports.getSessionsControllerListAttachmentsUrl = getSessionsControllerListAttachmentsUrl;
+const sessionsControllerListAttachments = async (id, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerListAttachmentsUrl)(id), {
+        ...options,
+        method: 'GET'
+    });
+};
+exports.sessionsControllerListAttachments = sessionsControllerListAttachments;
+/**
+ * @summary Remove attachment from session
+ */
+const getSessionsControllerRemoveAttachmentUrl = (id, attachmentId) => {
+    return `/sessions/${id}/attachments/${attachmentId}`;
+};
+exports.getSessionsControllerRemoveAttachmentUrl = getSessionsControllerRemoveAttachmentUrl;
+const sessionsControllerRemoveAttachment = async (id, attachmentId, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerRemoveAttachmentUrl)(id, attachmentId), {
+        ...options,
+        method: 'DELETE'
+    });
+};
+exports.sessionsControllerRemoveAttachment = sessionsControllerRemoveAttachment;
+/**
+ * @summary Initiate a direct-to-blob upload for a file attachment. Returns a short-lived presigned URL the browser uses to PUT the bytes straight to object storage; session-api never sees the buffer.
+ */
+const getSessionsControllerInitAttachmentUploadUrl = (id) => {
+    return `/sessions/${id}/attachments/upload-init`;
+};
+exports.getSessionsControllerInitAttachmentUploadUrl = getSessionsControllerInitAttachmentUploadUrl;
+const sessionsControllerInitAttachmentUpload = async (id, initAttachmentUploadDto, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerInitAttachmentUploadUrl)(id), {
+        ...options,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(initAttachmentUploadDto)
+    });
+};
+exports.sessionsControllerInitAttachmentUpload = sessionsControllerInitAttachmentUpload;
+/**
+ * @summary Finalise a SAS upload. Verifies the blob landed in storage, flips the attachment to ready, and projects the file into the live workspace via the workspace-proxy SAS-pull endpoint so the agent sees it immediately.
+ */
+const getSessionsControllerCompleteAttachmentUploadUrl = (id, attachmentId) => {
+    return `/sessions/${id}/attachments/${attachmentId}/upload-complete`;
+};
+exports.getSessionsControllerCompleteAttachmentUploadUrl = getSessionsControllerCompleteAttachmentUploadUrl;
+const sessionsControllerCompleteAttachmentUpload = async (id, attachmentId, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerCompleteAttachmentUploadUrl)(id, attachmentId), {
+        ...options,
+        method: 'POST'
+    });
+};
+exports.sessionsControllerCompleteAttachmentUpload = sessionsControllerCompleteAttachmentUpload;
+/**
+ * @summary Get session token usage and budget status
+ */
+const getSessionsControllerGetUsageUrl = (id) => {
+    return `/sessions/${id}/usage`;
+};
+exports.getSessionsControllerGetUsageUrl = getSessionsControllerGetUsageUrl;
+const sessionsControllerGetUsage = async (id, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerGetUsageUrl)(id), {
+        ...options,
+        method: 'GET'
+    });
+};
+exports.sessionsControllerGetUsage = sessionsControllerGetUsage;
+/**
+ * @summary Per-session MCP tool-usage counters (Phase E telemetry). Returns one row per (mcpServiceSlug, command) tuple, sorted by count desc. Counters live in Redis with a 30-day TTL; an unreachable telemetry store yields an empty list plus a `warning` string instead of an error — the read is debug-grade and never blocks the UI.
+ */
+const getSessionsControllerGetToolUsageUrl = (id) => {
+    return `/sessions/${id}/tool-usage`;
+};
+exports.getSessionsControllerGetToolUsageUrl = getSessionsControllerGetToolUsageUrl;
+const sessionsControllerGetToolUsage = async (id, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerGetToolUsageUrl)(id), {
+        ...options,
+        method: 'GET'
+    });
+};
+exports.sessionsControllerGetToolUsage = sessionsControllerGetToolUsage;
+/**
+ * @summary Create or switch git branch. Requires turnState=idle.
+ */
+const getSessionsControllerCreateBranchUrl = (id) => {
+    return `/sessions/${id}/git/branch`;
+};
+exports.getSessionsControllerCreateBranchUrl = getSessionsControllerCreateBranchUrl;
+const sessionsControllerCreateBranch = async (id, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerCreateBranchUrl)(id), {
+        ...options,
+        method: 'POST'
+    });
+};
+exports.sessionsControllerCreateBranch = sessionsControllerCreateBranch;
+/**
+ * @summary Get git status (modified, staged, branch)
+ */
+const getSessionsControllerGetGitStatusUrl = (id) => {
+    return `/sessions/${id}/git/status`;
+};
+exports.getSessionsControllerGetGitStatusUrl = getSessionsControllerGetGitStatusUrl;
+const sessionsControllerGetGitStatus = async (id, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerGetGitStatusUrl)(id), {
+        ...options,
+        method: 'GET'
+    });
+};
+exports.sessionsControllerGetGitStatus = sessionsControllerGetGitStatus;
+/**
+ * @summary Get git diff (staged or unstaged). When `path` is provided, the diff is scoped to that single file — used by the UI to render a per-file diff viewer on top of the changed-files panel.
+ */
+const getSessionsControllerGetGitDiffUrl = (id, params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value === undefined)
+            return;
+        if (value === null) {
+            normalizedParams.append(key, 'null');
+            return;
+        }
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                if (item === undefined || item === null)
+                    continue;
+                normalizedParams.append(key, item.toString());
+            }
+            return;
+        }
+        normalizedParams.append(key, value.toString());
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0 ? `/sessions/${id}/git/diff?${stringifiedParams}` : `/sessions/${id}/git/diff`;
+};
+exports.getSessionsControllerGetGitDiffUrl = getSessionsControllerGetGitDiffUrl;
+const sessionsControllerGetGitDiff = async (id, params, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerGetGitDiffUrl)(id, params), {
+        ...options,
+        method: 'GET'
+    });
+};
+exports.sessionsControllerGetGitDiff = sessionsControllerGetGitDiff;
+/**
+ * @summary Commit changes. Author=user, co-author=agent. Requires turnState=idle.
+ */
+const getSessionsControllerGitCommitUrl = (id) => {
+    return `/sessions/${id}/git/commit`;
+};
+exports.getSessionsControllerGitCommitUrl = getSessionsControllerGitCommitUrl;
+const sessionsControllerGitCommit = async (id, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerGitCommitUrl)(id), {
+        ...options,
+        method: 'POST'
+    });
+};
+exports.sessionsControllerGitCommit = sessionsControllerGitCommit;
+/**
+ * @summary Push to remote. Requires turnState=idle.
+ */
+const getSessionsControllerGitPushUrl = (id) => {
+    return `/sessions/${id}/git/push`;
+};
+exports.getSessionsControllerGitPushUrl = getSessionsControllerGitPushUrl;
+const sessionsControllerGitPush = async (id, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerGitPushUrl)(id), {
+        ...options,
+        method: 'POST'
+    });
+};
+exports.sessionsControllerGitPush = sessionsControllerGitPush;
+/**
+ * @summary Create pull request from session branch
+ */
+const getSessionsControllerCreatePullRequestUrl = (id) => {
+    return `/sessions/${id}/git/pull-request`;
+};
+exports.getSessionsControllerCreatePullRequestUrl = getSessionsControllerCreatePullRequestUrl;
+const sessionsControllerCreatePullRequest = async (id, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerCreatePullRequestUrl)(id), {
+        ...options,
+        method: 'POST'
+    });
+};
+exports.sessionsControllerCreatePullRequest = sessionsControllerCreatePullRequest;
+/**
+ * @summary Get commit history for session branch
+ */
+const getSessionsControllerGetCommitHistoryUrl = (id, params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value === undefined)
+            return;
+        if (value === null) {
+            normalizedParams.append(key, 'null');
+            return;
+        }
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                if (item === undefined || item === null)
+                    continue;
+                normalizedParams.append(key, item.toString());
+            }
+            return;
+        }
+        normalizedParams.append(key, value.toString());
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0 ? `/sessions/${id}/git/commits?${stringifiedParams}` : `/sessions/${id}/git/commits`;
+};
+exports.getSessionsControllerGetCommitHistoryUrl = getSessionsControllerGetCommitHistoryUrl;
+const sessionsControllerGetCommitHistory = async (id, params, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerGetCommitHistoryUrl)(id, params), {
+        ...options,
+        method: 'GET'
+    });
+};
+exports.sessionsControllerGetCommitHistory = sessionsControllerGetCommitHistory;
+/**
+ * @summary Check if the session branch can merge cleanly into the target branch. Uses git merge-tree (no workspace mutation).
+ */
+const getSessionsControllerMergeCheckUrl = (id, params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value === undefined)
+            return;
+        if (value === null) {
+            normalizedParams.append(key, 'null');
+            return;
+        }
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                if (item === undefined || item === null)
+                    continue;
+                normalizedParams.append(key, item.toString());
+            }
+            return;
+        }
+        normalizedParams.append(key, value.toString());
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0 ? `/sessions/${id}/git/merge-check?${stringifiedParams}` : `/sessions/${id}/git/merge-check`;
+};
+exports.getSessionsControllerMergeCheckUrl = getSessionsControllerMergeCheckUrl;
+const sessionsControllerMergeCheck = async (id, params, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerMergeCheckUrl)(id, params), {
+        ...options,
+        method: 'GET'
+    });
+};
+exports.sessionsControllerMergeCheck = sessionsControllerMergeCheck;
+/**
+ * @summary Push content to knowledge base as a new or updated page
+ */
+const getSessionsControllerPushToKBUrl = (id) => {
+    return `/sessions/${id}/kb-push`;
+};
+exports.getSessionsControllerPushToKBUrl = getSessionsControllerPushToKBUrl;
+const sessionsControllerPushToKB = async (id, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerPushToKBUrl)(id), {
+        ...options,
+        method: 'POST'
+    });
+};
+exports.sessionsControllerPushToKB = sessionsControllerPushToKB;
+/**
+ * @summary Create a session template
+ */
+const getSessionsControllerCreateTemplateUrl = () => {
+    return `/sessions/templates`;
+};
+exports.getSessionsControllerCreateTemplateUrl = getSessionsControllerCreateTemplateUrl;
+const sessionsControllerCreateTemplate = async (options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerCreateTemplateUrl)(), {
+        ...options,
+        method: 'POST'
+    });
+};
+exports.sessionsControllerCreateTemplate = sessionsControllerCreateTemplate;
+/**
+ * @summary List session templates
+ */
+const getSessionsControllerListTemplatesUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value === undefined)
+            return;
+        if (value === null) {
+            normalizedParams.append(key, 'null');
+            return;
+        }
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                if (item === undefined || item === null)
+                    continue;
+                normalizedParams.append(key, item.toString());
+            }
+            return;
+        }
+        normalizedParams.append(key, value.toString());
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0 ? `/sessions/templates?${stringifiedParams}` : `/sessions/templates`;
+};
+exports.getSessionsControllerListTemplatesUrl = getSessionsControllerListTemplatesUrl;
+const sessionsControllerListTemplates = async (params, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerListTemplatesUrl)(params), {
+        ...options,
+        method: 'GET'
+    });
+};
+exports.sessionsControllerListTemplates = sessionsControllerListTemplates;
+/**
+ * @summary Get template by ID
+ */
+const getSessionsControllerGetTemplateUrl = (templateId) => {
+    return `/sessions/templates/${templateId}`;
+};
+exports.getSessionsControllerGetTemplateUrl = getSessionsControllerGetTemplateUrl;
+const sessionsControllerGetTemplate = async (templateId, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerGetTemplateUrl)(templateId), {
+        ...options,
+        method: 'GET'
+    });
+};
+exports.sessionsControllerGetTemplate = sessionsControllerGetTemplate;
+/**
+ * @summary Update a session template
+ */
+const getSessionsControllerUpdateTemplateUrl = (templateId) => {
+    return `/sessions/templates/${templateId}`;
+};
+exports.getSessionsControllerUpdateTemplateUrl = getSessionsControllerUpdateTemplateUrl;
+const sessionsControllerUpdateTemplate = async (templateId, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerUpdateTemplateUrl)(templateId), {
+        ...options,
+        method: 'POST'
+    });
+};
+exports.sessionsControllerUpdateTemplate = sessionsControllerUpdateTemplate;
+/**
+ * @summary Delete a session template
+ */
+const getSessionsControllerDeleteTemplateUrl = (templateId) => {
+    return `/sessions/templates/${templateId}`;
+};
+exports.getSessionsControllerDeleteTemplateUrl = getSessionsControllerDeleteTemplateUrl;
+const sessionsControllerDeleteTemplate = async (templateId, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerDeleteTemplateUrl)(templateId), {
+        ...options,
+        method: 'DELETE'
+    });
+};
+exports.sessionsControllerDeleteTemplate = sessionsControllerDeleteTemplate;
+/**
+ * @summary Clone a session template
+ */
+const getSessionsControllerCloneTemplateUrl = (templateId) => {
+    return `/sessions/templates/${templateId}/clone`;
+};
+exports.getSessionsControllerCloneTemplateUrl = getSessionsControllerCloneTemplateUrl;
+const sessionsControllerCloneTemplate = async (templateId, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerCloneTemplateUrl)(templateId), {
+        ...options,
+        method: 'POST'
+    });
+};
+exports.sessionsControllerCloneTemplate = sessionsControllerCloneTemplate;
+/**
+ * @summary Generate a read-only sharing link for the session
+ */
+const getSessionsControllerCreateShareUrl = (id) => {
+    return `/sessions/${id}/share`;
+};
+exports.getSessionsControllerCreateShareUrl = getSessionsControllerCreateShareUrl;
+const sessionsControllerCreateShare = async (id, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionsControllerCreateShareUrl)(id), {
+        ...options,
+        method: 'POST'
+    });
+};
+exports.sessionsControllerCreateShare = sessionsControllerCreateShare;
+/**
+ * @summary Start a Kaniko-based container-image build for the session's primary repo HEAD. Dispatches `buildContainerImageWorkflow` on the xema-platform-worker. Idempotent per (sessionId, sha): a duplicate call returns the existing run id. Only standard interactive sessions can build — pipeline + sandbox sessions are rejected.
+ */
+const getBuildImageControllerStartUrl = (id) => {
+    return `/sessions/${id}/build-image`;
+};
+exports.getBuildImageControllerStartUrl = getBuildImageControllerStartUrl;
+const buildImageControllerStart = async (id, startBuildImageDto, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getBuildImageControllerStartUrl)(id), {
+        ...options,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(startBuildImageDto)
+    });
+};
+exports.buildImageControllerStart = buildImageControllerStart;
+/**
+ * @summary Describe a previously-started build-image workflow. The FE polls this to flip the button between Building… / Completed / Failed.
+ */
+const getBuildImageControllerStatusUrl = (id, workflowId) => {
+    return `/sessions/${id}/build-image/${workflowId}`;
+};
+exports.getBuildImageControllerStatusUrl = getBuildImageControllerStatusUrl;
+const buildImageControllerStatus = async (id, workflowId, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getBuildImageControllerStatusUrl)(id, workflowId), {
+        ...options,
+        method: 'GET'
+    });
+};
+exports.buildImageControllerStatus = buildImageControllerStatus;