@xemahq/agent-session-api-client 0.1.2

package/dist/endpoints/sandbox-sessions/sandbox-sessions.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sandboxSessionsControllerDebug = exports.getSandboxSessionsControllerDebugUrl = exports.sandboxSessionsControllerDispose = exports.getSandboxSessionsControllerDisposeUrl = exports.sandboxSessionsControllerRunEvalTurn = exports.getSandboxSessionsControllerRunEvalTurnUrl = exports.sandboxSessionsControllerDeleteToolMocks = exports.getSandboxSessionsControllerDeleteToolMocksUrl = exports.sandboxSessionsControllerListToolMocks = exports.getSandboxSessionsControllerListToolMocksUrl = exports.sandboxSessionsControllerSetToolMocks = exports.getSandboxSessionsControllerSetToolMocksUrl = exports.sandboxSessionsControllerCreate = exports.getSandboxSessionsControllerCreateUrl = void 0;
+const custom_fetch_1 = require("../../custom-fetch");
+/**
+ * @summary Create an ephemeral Agent Studio sandbox session bound to a DRAFT composition. The session is throwaway, lifecycle-bounded by a TTL, and isolated from every project side-effect (no artifact emit, no deliverable harvest, no KB push, no git, no snapshot persistence). When `toolMocks` is supplied the per-tool canned responses are registered with the mcp-gateway test-mode mock bridge as part of create.
+ */
+const getSandboxSessionsControllerCreateUrl = () => {
+    return `/sessions/sandbox`;
+};
+exports.getSandboxSessionsControllerCreateUrl = getSandboxSessionsControllerCreateUrl;
+const sandboxSessionsControllerCreate = async (createSandboxSessionDto, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSandboxSessionsControllerCreateUrl)(), {
+        ...options,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(createSandboxSessionDto)
+    });
+};
+exports.sandboxSessionsControllerCreate = sandboxSessionsControllerCreate;
+/**
+ * @summary Register (replace) the full set of per-tool canned mock responses for a sandbox session. When the sandbox runs with mocked tools, the mcp-gateway bridge serves these canned results instead of invoking live MCP services. Authorized as the sandbox owner; forwarded to mcp-gateway-api service-to-service.
+ */
+const getSandboxSessionsControllerSetToolMocksUrl = (id) => {
+    return `/sessions/sandbox/${id}/tool-mocks`;
+};
+exports.getSandboxSessionsControllerSetToolMocksUrl = getSandboxSessionsControllerSetToolMocksUrl;
+const sandboxSessionsControllerSetToolMocks = async (id, setSandboxToolMocksDto, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSandboxSessionsControllerSetToolMocksUrl)(id), {
+        ...options,
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(setSandboxToolMocksDto)
+    });
+};
+exports.sandboxSessionsControllerSetToolMocks = sandboxSessionsControllerSetToolMocks;
+/**
+ * @summary List the canonical tool names a sandbox session currently has canned mock responses registered for.
+ */
+const getSandboxSessionsControllerListToolMocksUrl = (id) => {
+    return `/sessions/sandbox/${id}/tool-mocks`;
+};
+exports.getSandboxSessionsControllerListToolMocksUrl = getSandboxSessionsControllerListToolMocksUrl;
+const sandboxSessionsControllerListToolMocks = async (id, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSandboxSessionsControllerListToolMocksUrl)(id), {
+        ...options,
+        method: 'GET'
+    });
+};
+exports.sandboxSessionsControllerListToolMocks = sandboxSessionsControllerListToolMocks;
+/**
+ * @summary Delete one mocked tool from a sandbox session, or every mock for the session when the `toolName` query parameter is omitted.
+ */
+const getSandboxSessionsControllerDeleteToolMocksUrl = (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/sandbox/${id}/tool-mocks?${stringifiedParams}` : `/sessions/sandbox/${id}/tool-mocks`;
+};
+exports.getSandboxSessionsControllerDeleteToolMocksUrl = getSandboxSessionsControllerDeleteToolMocksUrl;
+const sandboxSessionsControllerDeleteToolMocks = async (id, params, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSandboxSessionsControllerDeleteToolMocksUrl)(id, params), {
+        ...options,
+        method: 'DELETE'
+    });
+};
+exports.sandboxSessionsControllerDeleteToolMocks = sandboxSessionsControllerDeleteToolMocks;
+/**
+ * @summary Drive ONE agent turn on a sandbox session to completion SYNCHRONOUSLY and return the captured assistant output + token/wall-clock timing. Unlike the SSE chat endpoint this blocks until the turn reaches its terminal state — built for the skill-registry-api eval harness, which is a service-to-service caller and cannot consume an event stream. Requires an `Idempotency-Key` header: it is the per-turn lock id, so a retried eval turn never double-drives the agent.
+ */
+const getSandboxSessionsControllerRunEvalTurnUrl = (id) => {
+    return `/sessions/sandbox/${id}/eval-turn`;
+};
+exports.getSandboxSessionsControllerRunEvalTurnUrl = getSandboxSessionsControllerRunEvalTurnUrl;
+const sandboxSessionsControllerRunEvalTurn = async (id, runSandboxEvalTurnDto, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSandboxSessionsControllerRunEvalTurnUrl)(id), {
+        ...options,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(runSandboxEvalTurnDto)
+    });
+};
+exports.sandboxSessionsControllerRunEvalTurn = sandboxSessionsControllerRunEvalTurn;
+/**
+ * @summary Dispose a sandbox session — release its worker and drive it terminal. Idempotent.
+ */
+const getSandboxSessionsControllerDisposeUrl = (id) => {
+    return `/sessions/sandbox/${id}`;
+};
+exports.getSandboxSessionsControllerDisposeUrl = getSandboxSessionsControllerDisposeUrl;
+const sandboxSessionsControllerDispose = async (id, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSandboxSessionsControllerDisposeUrl)(id), {
+        ...options,
+        method: 'DELETE'
+    });
+};
+exports.sandboxSessionsControllerDispose = sandboxSessionsControllerDispose;
+/**
+ * @summary Debug / decision-trace view of a (sandbox) session: the resolved composition tree (sub-agent tree + per-node model), the Model Resolution Matrix decision trace for the primary agent, skill activation, the injected-context view, and the projected mount plan. Valid for any session; built for the Studio sandbox harness.
+ */
+const getSandboxSessionsControllerDebugUrl = (id) => {
+    return `/sessions/sandbox/${id}/debug`;
+};
+exports.getSandboxSessionsControllerDebugUrl = getSandboxSessionsControllerDebugUrl;
+const sandboxSessionsControllerDebug = async (id, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSandboxSessionsControllerDebugUrl)(id), {
+        ...options,
+        method: 'GET'
+    });
+};
+exports.sandboxSessionsControllerDebug = sandboxSessionsControllerDebug;

package/dist/endpoints/session-attachments/session-attachments.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Generated by orval v8.6.2 🍺
+ * Do not edit manually.
+ * Interactive Session API
+ * Real-time interactive AI coding sessions with agent management, file browsing, and activity streaming
+ * OpenAPI spec version: 0.1.0
+ */
+import type { AttachSkillDto } from '../../models';
+/**
+ * @summary List skills attached to this session
+ */
+export declare const getSessionAttachmentsControllerListSkillsUrl: (id: string) => string;
+export declare const sessionAttachmentsControllerListSkills: (id: string, options?: RequestInit) => Promise<void>;
+/**
+ * @summary Attach a skill to this session at runtime
+ */
+export declare const getSessionAttachmentsControllerAttachSkillUrl: (id: string) => string;
+export declare const sessionAttachmentsControllerAttachSkill: (id: string, attachSkillDto: AttachSkillDto, options?: RequestInit) => Promise<void>;
+/**
+ * @summary Detach a skill from this session
+ */
+export declare const getSessionAttachmentsControllerDetachSkillUrl: (id: string, skillSlug: string) => string;
+export declare const sessionAttachmentsControllerDetachSkill: (id: string, skillSlug: string, options?: RequestInit) => Promise<void>;

package/dist/endpoints/session-attachments/session-attachments.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sessionAttachmentsControllerDetachSkill = exports.getSessionAttachmentsControllerDetachSkillUrl = exports.sessionAttachmentsControllerAttachSkill = exports.getSessionAttachmentsControllerAttachSkillUrl = exports.sessionAttachmentsControllerListSkills = exports.getSessionAttachmentsControllerListSkillsUrl = void 0;
+const custom_fetch_1 = require("../../custom-fetch");
+/**
+ * @summary List skills attached to this session
+ */
+const getSessionAttachmentsControllerListSkillsUrl = (id) => {
+    return `/sessions/${id}/skills`;
+};
+exports.getSessionAttachmentsControllerListSkillsUrl = getSessionAttachmentsControllerListSkillsUrl;
+const sessionAttachmentsControllerListSkills = async (id, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionAttachmentsControllerListSkillsUrl)(id), {
+        ...options,
+        method: 'GET'
+    });
+};
+exports.sessionAttachmentsControllerListSkills = sessionAttachmentsControllerListSkills;
+/**
+ * @summary Attach a skill to this session at runtime
+ */
+const getSessionAttachmentsControllerAttachSkillUrl = (id) => {
+    return `/sessions/${id}/skills`;
+};
+exports.getSessionAttachmentsControllerAttachSkillUrl = getSessionAttachmentsControllerAttachSkillUrl;
+const sessionAttachmentsControllerAttachSkill = async (id, attachSkillDto, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionAttachmentsControllerAttachSkillUrl)(id), {
+        ...options,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(attachSkillDto)
+    });
+};
+exports.sessionAttachmentsControllerAttachSkill = sessionAttachmentsControllerAttachSkill;
+/**
+ * @summary Detach a skill from this session
+ */
+const getSessionAttachmentsControllerDetachSkillUrl = (id, skillSlug) => {
+    return `/sessions/${id}/skills/${skillSlug}`;
+};
+exports.getSessionAttachmentsControllerDetachSkillUrl = getSessionAttachmentsControllerDetachSkillUrl;
+const sessionAttachmentsControllerDetachSkill = async (id, skillSlug, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionAttachmentsControllerDetachSkillUrl)(id, skillSlug), {
+        ...options,
+        method: 'DELETE'
+    });
+};
+exports.sessionAttachmentsControllerDetachSkill = sessionAttachmentsControllerDetachSkill;

package/dist/endpoints/session-blob-attachments/session-blob-attachments.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Generated by orval v8.6.2 🍺
+ * Do not edit manually.
+ * Interactive Session API
+ * Real-time interactive AI coding sessions with agent management, file browsing, and activity streaming
+ * OpenAPI spec version: 0.1.0
+ */
+import type { SessionBlobAttachmentDtoDataArrayEnvelope } from '../../models';
+/**
+ * @summary List uploaded-file attachments for a session with per-row SAS download URLs (mount-apply manifest)
+ */
+export declare const getSessionBlobAttachmentsControllerListUrl: (id: string) => string;
+export declare const sessionBlobAttachmentsControllerList: (id: string, options?: RequestInit) => Promise<SessionBlobAttachmentDtoDataArrayEnvelope>;

package/dist/endpoints/session-blob-attachments/session-blob-attachments.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sessionBlobAttachmentsControllerList = exports.getSessionBlobAttachmentsControllerListUrl = void 0;
+const custom_fetch_1 = require("../../custom-fetch");
+/**
+ * @summary List uploaded-file attachments for a session with per-row SAS download URLs (mount-apply manifest)
+ */
+const getSessionBlobAttachmentsControllerListUrl = (id) => {
+    return `/sessions/${id}/attachments/blob-manifest`;
+};
+exports.getSessionBlobAttachmentsControllerListUrl = getSessionBlobAttachmentsControllerListUrl;
+const sessionBlobAttachmentsControllerList = async (id, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getSessionBlobAttachmentsControllerListUrl)(id), {
+        ...options,
+        method: 'GET'
+    });
+};
+exports.sessionBlobAttachmentsControllerList = sessionBlobAttachmentsControllerList;

package/dist/endpoints/session-participants/session-participants.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Generated by orval v8.6.2 🍺
+ * Do not edit manually.
+ * Interactive Session API
+ * Real-time interactive AI coding sessions with agent management, file browsing, and activity streaming
+ * OpenAPI spec version: 0.1.0
+ */
+import type { InviteExternalDto, InviteParticipantDto, InvitedExternalParticipantResponseDtoDataEnvelope, ListSessionParticipantsResponseDtoDataEnvelope, SessionParticipantDtoDataEnvelope } from '../../models';
+/**
+ * @summary List the participants of a session (capability `workspace:session.read@1`). Returns every Xema user + external guest currently invited, including their role, invited-at, and last-seen-at.
+ */
+export declare const getParticipantsControllerListUrl: (sessionId: string) => string;
+export declare const participantsControllerList: (sessionId: string, options?: RequestInit) => Promise<ListSessionParticipantsResponseDtoDataEnvelope>;
+/**
+ * @summary Invite an in-org Xema user to a session (capability `workspace:session.invite@1`). Use `POST /participants/external` for external guest invites.
+ */
+export declare const getParticipantsControllerInviteUrl: (sessionId: string) => string;
+export declare const participantsControllerInvite: (sessionId: string, inviteParticipantDto: InviteParticipantDto, options?: RequestInit) => Promise<SessionParticipantDtoDataEnvelope>;
+/**
+ * @summary Invite an external guest (delegated-session subject) to an app-layer session (capability `workspace:session.invite-external@1`). Refuses with `SESSION_LAYER_REJECTS_EXTERNAL` (409) when the session is not on `layer == "app"`. Mints a short-lived delegated token via app-runtime-api and returns the join URL.
+ */
+export declare const getParticipantsControllerInviteExternalUrl: (sessionId: string) => string;
+export declare const participantsControllerInviteExternal: (sessionId: string, inviteExternalDto: InviteExternalDto, options?: RequestInit) => Promise<InvitedExternalParticipantResponseDtoDataEnvelope>;
+/**
+ * @summary Remove a participant from a session (capability `workspace:session.invite@1`). The session owner cannot be removed.
+ */
+export declare const getParticipantsControllerRemoveUrl: (sessionId: string, participantId: string) => string;
+export declare const participantsControllerRemove: (sessionId: string, participantId: string, options?: RequestInit) => Promise<unknown>;

package/dist/endpoints/session-participants/session-participants.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.participantsControllerRemove = exports.getParticipantsControllerRemoveUrl = exports.participantsControllerInviteExternal = exports.getParticipantsControllerInviteExternalUrl = exports.participantsControllerInvite = exports.getParticipantsControllerInviteUrl = exports.participantsControllerList = exports.getParticipantsControllerListUrl = void 0;
+const custom_fetch_1 = require("../../custom-fetch");
+/**
+ * @summary List the participants of a session (capability `workspace:session.read@1`). Returns every Xema user + external guest currently invited, including their role, invited-at, and last-seen-at.
+ */
+const getParticipantsControllerListUrl = (sessionId) => {
+    return `/sessions/${sessionId}/participants`;
+};
+exports.getParticipantsControllerListUrl = getParticipantsControllerListUrl;
+const participantsControllerList = async (sessionId, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getParticipantsControllerListUrl)(sessionId), {
+        ...options,
+        method: 'GET'
+    });
+};
+exports.participantsControllerList = participantsControllerList;
+/**
+ * @summary Invite an in-org Xema user to a session (capability `workspace:session.invite@1`). Use `POST /participants/external` for external guest invites.
+ */
+const getParticipantsControllerInviteUrl = (sessionId) => {
+    return `/sessions/${sessionId}/participants`;
+};
+exports.getParticipantsControllerInviteUrl = getParticipantsControllerInviteUrl;
+const participantsControllerInvite = async (sessionId, inviteParticipantDto, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getParticipantsControllerInviteUrl)(sessionId), {
+        ...options,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(inviteParticipantDto)
+    });
+};
+exports.participantsControllerInvite = participantsControllerInvite;
+/**
+ * @summary Invite an external guest (delegated-session subject) to an app-layer session (capability `workspace:session.invite-external@1`). Refuses with `SESSION_LAYER_REJECTS_EXTERNAL` (409) when the session is not on `layer == "app"`. Mints a short-lived delegated token via app-runtime-api and returns the join URL.
+ */
+const getParticipantsControllerInviteExternalUrl = (sessionId) => {
+    return `/sessions/${sessionId}/participants/external`;
+};
+exports.getParticipantsControllerInviteExternalUrl = getParticipantsControllerInviteExternalUrl;
+const participantsControllerInviteExternal = async (sessionId, inviteExternalDto, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getParticipantsControllerInviteExternalUrl)(sessionId), {
+        ...options,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(inviteExternalDto)
+    });
+};
+exports.participantsControllerInviteExternal = participantsControllerInviteExternal;
+/**
+ * @summary Remove a participant from a session (capability `workspace:session.invite@1`). The session owner cannot be removed.
+ */
+const getParticipantsControllerRemoveUrl = (sessionId, participantId) => {
+    return `/sessions/${sessionId}/participants/${participantId}`;
+};
+exports.getParticipantsControllerRemoveUrl = getParticipantsControllerRemoveUrl;
+const participantsControllerRemove = async (sessionId, participantId, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getParticipantsControllerRemoveUrl)(sessionId, participantId), {
+        ...options,
+        method: 'DELETE'
+    });
+};
+exports.participantsControllerRemove = participantsControllerRemove;

package/dist/endpoints/sessions/sessions.d.ts

@@ -0,0 +1,243 @@
+/**
+ * Generated by orval v8.6.2 🍺
+ * Do not edit manually.
+ * Interactive Session API
+ * Real-time interactive AI coding sessions with agent management, file browsing, and activity streaming
+ * OpenAPI spec version: 0.1.0
+ */
+import type { AddAttachmentDto, AttachmentResponseDtoDataArrayEnvelope, AttachmentResponseDtoDataEnvelope, AttachmentUploadInitResponseDtoDataEnvelope, BuildImageStartedResponseDtoDataEnvelope, BuildImageStatusResponseDtoDataEnvelope, ChangeSessionModelDto, ChangeSessionToolsDto, GitCommitEntryDtoDataArrayEnvelope, GitCommitResponseDtoDataEnvelope, GitStatusResponseDtoDataEnvelope, InitAttachmentUploadDto, KBPushResponseDtoDataEnvelope, KbMountsResponseDtoDataEnvelope, MergeCheckResponseDtoDataEnvelope, PullRequestResponseDtoDataEnvelope, PushDocumentEditDto, ResumeSessionDto, SessionLockfileDtoDataEnvelope, SessionResponseDtoDataEnvelope, SessionResponseDtoPaginatedEnvelope, SessionsControllerGetCommitHistoryParams, SessionsControllerGetGitDiffParams, SessionsControllerListFilesParams, SessionsControllerListParams, SessionsControllerListTemplatesParams, SessionsControllerMergeCheckParams, SessionsControllerStreamEventsParams, ShareResponseDtoDataEnvelope, StartBuildImageDto, TemplateResponseDtoDataEnvelope, TemplateResponseDtoPaginatedEnvelope, ToolUsageResponseDtoDataEnvelope, UpdateKbMountsDto, UsageResponseDtoDataEnvelope } from '../../models';
+/**
+ * @summary Create a new agent session
+ */
+export declare const getSessionsControllerCreateUrl: () => string;
+export declare const sessionsControllerCreate: (options?: RequestInit) => Promise<SessionResponseDtoDataEnvelope>;
+/**
+ * @summary List sessions with pagination and filters
+ */
+export declare const getSessionsControllerListUrl: (params?: SessionsControllerListParams) => string;
+export declare const sessionsControllerList: (params?: SessionsControllerListParams, options?: RequestInit) => Promise<SessionResponseDtoPaginatedEnvelope>;
+/**
+ * @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.
+ */
+export declare const getSessionsControllerForkUrl: (id: string) => string;
+export declare const sessionsControllerFork: (id: string, options?: RequestInit) => Promise<SessionResponseDtoDataEnvelope>;
+/**
+ * @summary Get session detail
+ */
+export declare const getSessionsControllerGetByIdUrl: (id: string) => string;
+export declare const sessionsControllerGetById: (id: string, options?: RequestInit) => Promise<SessionResponseDtoDataEnvelope>;
+/**
+ * @summary Terminate and archive a session
+ */
+export declare const getSessionsControllerTerminateUrl: (id: string) => string;
+export declare const sessionsControllerTerminate: (id: string, options?: RequestInit) => Promise<SessionResponseDtoDataEnvelope>;
+/**
+ * @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.
+ */
+export declare const getSessionsControllerGetLockfileUrl: (id: string) => string;
+export declare const sessionsControllerGetLockfile: (id: string, options?: RequestInit) => Promise<SessionLockfileDtoDataEnvelope>;
+/**
+ * @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.
+ */
+export declare const getSessionsControllerTerminateByPipelineRunIdUrl: (pipelineRunId: string) => string;
+export declare const sessionsControllerTerminateByPipelineRunId: (pipelineRunId: string, options?: RequestInit) => Promise<unknown>;
+/**
+ * @summary Reply to a question posed by the agent during a turn
+ */
+export declare const getSessionsControllerReplyToQuestionUrl: (id: string, requestId: string) => string;
+export declare const sessionsControllerReplyToQuestion: (id: string, requestId: string, options?: RequestInit) => Promise<unknown>;
+/**
+ * @summary Reject/dismiss a question posed by the agent during a turn
+ */
+export declare const getSessionsControllerRejectQuestionUrl: (id: string, requestId: string) => string;
+export declare const sessionsControllerRejectQuestion: (id: string, requestId: string, options?: RequestInit) => Promise<unknown>;
+/**
+ * @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.
+ */
+export declare const getSessionsControllerStreamEventsUrl: (id: string, params?: SessionsControllerStreamEventsParams) => string;
+export declare const sessionsControllerStreamEvents: (id: string, params?: SessionsControllerStreamEventsParams, options?: RequestInit) => Promise<unknown>;
+/**
+ * @summary Browse workspace file tree (scoped proxy with security boundary)
+ */
+export declare const getSessionsControllerListFilesUrl: (id: string, params?: SessionsControllerListFilesParams) => string;
+export declare const sessionsControllerListFiles: (id: string, params?: SessionsControllerListFilesParams, options?: RequestInit) => Promise<unknown>;
+/**
+ * @summary Read file content from workspace (scoped proxy, deny list enforced, 1MB limit)
+ */
+export declare const getSessionsControllerReadFileUrl: (id: string, filePath: unknown) => string;
+export declare const sessionsControllerReadFile: (id: string, filePath: unknown, options?: RequestInit) => Promise<unknown>;
+/**
+ * @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.
+ */
+export declare const getSessionsControllerPushDocumentEditUrl: (id: string) => string;
+export declare const sessionsControllerPushDocumentEdit: (id: string, pushDocumentEditDto: PushDocumentEditDto, options?: RequestInit) => Promise<unknown>;
+/**
+ * @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.
+ */
+export declare const getSessionsControllerResyncDocumentUrl: (id: string) => string;
+export declare const sessionsControllerResyncDocument: (id: string, options?: RequestInit) => Promise<unknown>;
+/**
+ * @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).
+ */
+export declare const getSessionsControllerChangeModelUrl: (id: string) => string;
+export declare const sessionsControllerChangeModel: (id: string, changeSessionModelDto: ChangeSessionModelDto, options?: RequestInit) => Promise<unknown>;
+/**
+ * @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).
+ */
+export declare const getSessionsControllerChangeToolsUrl: (id: string) => string;
+export declare const sessionsControllerChangeTools: (id: string, changeSessionToolsDto: ChangeSessionToolsDto, options?: RequestInit) => Promise<unknown>;
+/**
+ * @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.
+ */
+export declare const getSessionsControllerListKbMountsUrl: (id: string) => string;
+export declare const sessionsControllerListKbMounts: (id: string, options?: RequestInit) => Promise<KbMountsResponseDtoDataEnvelope>;
+/**
+ * @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: [] }`.
+ */
+export declare const getSessionsControllerUpdateKbMountsUrl: (id: string) => string;
+export declare const sessionsControllerUpdateKbMounts: (id: string, updateKbMountsDto: UpdateKbMountsDto, options?: RequestInit) => Promise<KbMountsResponseDtoDataEnvelope>;
+/**
+ * @summary Pause session — snapshot to MinIO, release worker. Requires turnState=idle.
+ */
+export declare const getSessionsControllerPauseUrl: (id: string) => string;
+export declare const sessionsControllerPause: (id: string, options?: RequestInit) => Promise<unknown>;
+/**
+ * @summary Resume paused session — acquire worker, restore snapshot. Pass `agentSlugOverride` to recover a session whose primary agent was removed.
+ */
+export declare const getSessionsControllerResumeUrl: (id: string) => string;
+export declare const sessionsControllerResume: (id: string, resumeSessionDto: ResumeSessionDto, options?: RequestInit) => Promise<unknown>;
+/**
+ * @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.
+ */
+export declare const getSessionsControllerCompactUrl: (id: string) => string;
+export declare const sessionsControllerCompact: (id: string, options?: RequestInit) => Promise<unknown>;
+/**
+ * @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.
+ */
+export declare const getSessionsControllerArchiveUrl: (id: string) => string;
+export declare const sessionsControllerArchive: (id: string, options?: RequestInit) => Promise<unknown>;
+/**
+ * @summary Add reference-class attachment to session (kb_page / org_document / internal_url / repo_ref)
+ */
+export declare const getSessionsControllerAddAttachmentUrl: (id: string) => string;
+export declare const sessionsControllerAddAttachment: (id: string, addAttachmentDto: AddAttachmentDto, options?: RequestInit) => Promise<AttachmentResponseDtoDataEnvelope>;
+/**
+ * @summary List session attachments
+ */
+export declare const getSessionsControllerListAttachmentsUrl: (id: string) => string;
+export declare const sessionsControllerListAttachments: (id: string, options?: RequestInit) => Promise<AttachmentResponseDtoDataArrayEnvelope>;
+/**
+ * @summary Remove attachment from session
+ */
+export declare const getSessionsControllerRemoveAttachmentUrl: (id: string, attachmentId: string) => string;
+export declare const sessionsControllerRemoveAttachment: (id: string, attachmentId: string, options?: RequestInit) => Promise<unknown>;
+/**
+ * @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.
+ */
+export declare const getSessionsControllerInitAttachmentUploadUrl: (id: string) => string;
+export declare const sessionsControllerInitAttachmentUpload: (id: string, initAttachmentUploadDto: InitAttachmentUploadDto, options?: RequestInit) => Promise<AttachmentUploadInitResponseDtoDataEnvelope>;
+/**
+ * @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.
+ */
+export declare const getSessionsControllerCompleteAttachmentUploadUrl: (id: string, attachmentId: string) => string;
+export declare const sessionsControllerCompleteAttachmentUpload: (id: string, attachmentId: string, options?: RequestInit) => Promise<AttachmentResponseDtoDataEnvelope>;
+/**
+ * @summary Get session token usage and budget status
+ */
+export declare const getSessionsControllerGetUsageUrl: (id: string) => string;
+export declare const sessionsControllerGetUsage: (id: string, options?: RequestInit) => Promise<UsageResponseDtoDataEnvelope>;
+/**
+ * @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.
+ */
+export declare const getSessionsControllerGetToolUsageUrl: (id: string) => string;
+export declare const sessionsControllerGetToolUsage: (id: string, options?: RequestInit) => Promise<ToolUsageResponseDtoDataEnvelope>;
+/**
+ * @summary Create or switch git branch. Requires turnState=idle.
+ */
+export declare const getSessionsControllerCreateBranchUrl: (id: string) => string;
+export declare const sessionsControllerCreateBranch: (id: string, options?: RequestInit) => Promise<unknown>;
+/**
+ * @summary Get git status (modified, staged, branch)
+ */
+export declare const getSessionsControllerGetGitStatusUrl: (id: string) => string;
+export declare const sessionsControllerGetGitStatus: (id: string, options?: RequestInit) => Promise<GitStatusResponseDtoDataEnvelope>;
+/**
+ * @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.
+ */
+export declare const getSessionsControllerGetGitDiffUrl: (id: string, params?: SessionsControllerGetGitDiffParams) => string;
+export declare const sessionsControllerGetGitDiff: (id: string, params?: SessionsControllerGetGitDiffParams, options?: RequestInit) => Promise<unknown>;
+/**
+ * @summary Commit changes. Author=user, co-author=agent. Requires turnState=idle.
+ */
+export declare const getSessionsControllerGitCommitUrl: (id: string) => string;
+export declare const sessionsControllerGitCommit: (id: string, options?: RequestInit) => Promise<GitCommitResponseDtoDataEnvelope>;
+/**
+ * @summary Push to remote. Requires turnState=idle.
+ */
+export declare const getSessionsControllerGitPushUrl: (id: string) => string;
+export declare const sessionsControllerGitPush: (id: string, options?: RequestInit) => Promise<unknown>;
+/**
+ * @summary Create pull request from session branch
+ */
+export declare const getSessionsControllerCreatePullRequestUrl: (id: string) => string;
+export declare const sessionsControllerCreatePullRequest: (id: string, options?: RequestInit) => Promise<PullRequestResponseDtoDataEnvelope>;
+/**
+ * @summary Get commit history for session branch
+ */
+export declare const getSessionsControllerGetCommitHistoryUrl: (id: string, params?: SessionsControllerGetCommitHistoryParams) => string;
+export declare const sessionsControllerGetCommitHistory: (id: string, params?: SessionsControllerGetCommitHistoryParams, options?: RequestInit) => Promise<GitCommitEntryDtoDataArrayEnvelope>;
+/**
+ * @summary Check if the session branch can merge cleanly into the target branch. Uses git merge-tree (no workspace mutation).
+ */
+export declare const getSessionsControllerMergeCheckUrl: (id: string, params?: SessionsControllerMergeCheckParams) => string;
+export declare const sessionsControllerMergeCheck: (id: string, params?: SessionsControllerMergeCheckParams, options?: RequestInit) => Promise<MergeCheckResponseDtoDataEnvelope>;
+/**
+ * @summary Push content to knowledge base as a new or updated page
+ */
+export declare const getSessionsControllerPushToKBUrl: (id: string) => string;
+export declare const sessionsControllerPushToKB: (id: string, options?: RequestInit) => Promise<KBPushResponseDtoDataEnvelope>;
+/**
+ * @summary Create a session template
+ */
+export declare const getSessionsControllerCreateTemplateUrl: () => string;
+export declare const sessionsControllerCreateTemplate: (options?: RequestInit) => Promise<TemplateResponseDtoDataEnvelope>;
+/**
+ * @summary List session templates
+ */
+export declare const getSessionsControllerListTemplatesUrl: (params?: SessionsControllerListTemplatesParams) => string;
+export declare const sessionsControllerListTemplates: (params?: SessionsControllerListTemplatesParams, options?: RequestInit) => Promise<TemplateResponseDtoPaginatedEnvelope>;
+/**
+ * @summary Get template by ID
+ */
+export declare const getSessionsControllerGetTemplateUrl: (templateId: string) => string;
+export declare const sessionsControllerGetTemplate: (templateId: string, options?: RequestInit) => Promise<TemplateResponseDtoDataEnvelope>;
+/**
+ * @summary Update a session template
+ */
+export declare const getSessionsControllerUpdateTemplateUrl: (templateId: string) => string;
+export declare const sessionsControllerUpdateTemplate: (templateId: string, options?: RequestInit) => Promise<TemplateResponseDtoDataEnvelope>;
+/**
+ * @summary Delete a session template
+ */
+export declare const getSessionsControllerDeleteTemplateUrl: (templateId: string) => string;
+export declare const sessionsControllerDeleteTemplate: (templateId: string, options?: RequestInit) => Promise<unknown>;
+/**
+ * @summary Clone a session template
+ */
+export declare const getSessionsControllerCloneTemplateUrl: (templateId: string) => string;
+export declare const sessionsControllerCloneTemplate: (templateId: string, options?: RequestInit) => Promise<TemplateResponseDtoDataEnvelope>;
+/**
+ * @summary Generate a read-only sharing link for the session
+ */
+export declare const getSessionsControllerCreateShareUrl: (id: string) => string;
+export declare const sessionsControllerCreateShare: (id: string, options?: RequestInit) => Promise<ShareResponseDtoDataEnvelope>;
+/**
+ * @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.
+ */
+export declare const getBuildImageControllerStartUrl: (id: string) => string;
+export declare const buildImageControllerStart: (id: string, startBuildImageDto: StartBuildImageDto, options?: RequestInit) => Promise<BuildImageStartedResponseDtoDataEnvelope>;
+/**
+ * @summary Describe a previously-started build-image workflow. The FE polls this to flip the button between Building… / Completed / Failed.
+ */
+export declare const getBuildImageControllerStatusUrl: (id: string, workflowId: string) => string;
+export declare const buildImageControllerStatus: (id: string, workflowId: string, options?: RequestInit) => Promise<BuildImageStatusResponseDtoDataEnvelope>;