@xemahq/agent-session-api-client 0.1.2

package/dist/endpoints/internal/internal.js

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.internalSweepersControllerSandboxSessionTick = exports.getInternalSweepersControllerSandboxSessionTickUrl = exports.internalBackfillsControllerRunCompositionRefBatch = exports.getInternalBackfillsControllerRunCompositionRefBatchUrl = exports.internalSessionCheckpointControllerCheckpointTick = exports.getInternalSessionCheckpointControllerCheckpointTickUrl = exports.internalSessionLifecycleReconcileControllerReconcileTick = exports.getInternalSessionLifecycleReconcileControllerReconcileTickUrl = exports.internalSessionLifecycleStepControllerHibernateForcePause = exports.getInternalSessionLifecycleStepControllerHibernateForcePauseUrl = exports.internalSessionLifecycleStepControllerHibernateRun = exports.getInternalSessionLifecycleStepControllerHibernateRunUrl = exports.internalSessionLifecycleStepControllerResumeFail = exports.getInternalSessionLifecycleStepControllerResumeFailUrl = exports.internalSessionLifecycleStepControllerResumeRun = exports.getInternalSessionLifecycleStepControllerResumeRunUrl = exports.internalSessionLaunchControllerFail = exports.getInternalSessionLaunchControllerFailUrl = exports.internalSessionLaunchControllerFinalize = exports.getInternalSessionLaunchControllerFinalizeUrl = exports.internalSessionLaunchControllerApplyBootstrap = exports.getInternalSessionLaunchControllerApplyBootstrapUrl = exports.internalSessionLaunchControllerApplyControlBundle = exports.getInternalSessionLaunchControllerApplyControlBundleUrl = exports.internalSessionLaunchControllerAcquireWorker = exports.getInternalSessionLaunchControllerAcquireWorkerUrl = exports.internalSessionLaunchControllerResolveConfig = exports.getInternalSessionLaunchControllerResolveConfigUrl = void 0;
+const custom_fetch_1 = require("../../custom-fetch");
+/**
+ * @summary Launch step — resolve config (creating → provisioning)
+ */
+const getInternalSessionLaunchControllerResolveConfigUrl = (sessionId) => {
+    return `/internal/sessions/${sessionId}/launch/resolve-config`;
+};
+exports.getInternalSessionLaunchControllerResolveConfigUrl = getInternalSessionLaunchControllerResolveConfigUrl;
+const internalSessionLaunchControllerResolveConfig = async (sessionId, launchStepRequestDto, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getInternalSessionLaunchControllerResolveConfigUrl)(sessionId), {
+        ...options,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(launchStepRequestDto)
+    });
+};
+exports.internalSessionLaunchControllerResolveConfig = internalSessionLaunchControllerResolveConfig;
+/**
+ * @summary Launch step — acquire the pool worker
+ */
+const getInternalSessionLaunchControllerAcquireWorkerUrl = (sessionId) => {
+    return `/internal/sessions/${sessionId}/launch/acquire-worker`;
+};
+exports.getInternalSessionLaunchControllerAcquireWorkerUrl = getInternalSessionLaunchControllerAcquireWorkerUrl;
+const internalSessionLaunchControllerAcquireWorker = async (sessionId, launchStepRequestDto, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getInternalSessionLaunchControllerAcquireWorkerUrl)(sessionId), {
+        ...options,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(launchStepRequestDto)
+    });
+};
+exports.internalSessionLaunchControllerAcquireWorker = internalSessionLaunchControllerAcquireWorker;
+/**
+ * @summary Launch step — apply the per-session control bundle
+ */
+const getInternalSessionLaunchControllerApplyControlBundleUrl = (sessionId) => {
+    return `/internal/sessions/${sessionId}/launch/apply-control-bundle`;
+};
+exports.getInternalSessionLaunchControllerApplyControlBundleUrl = getInternalSessionLaunchControllerApplyControlBundleUrl;
+const internalSessionLaunchControllerApplyControlBundle = async (sessionId, launchStepRequestDto, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getInternalSessionLaunchControllerApplyControlBundleUrl)(sessionId), {
+        ...options,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(launchStepRequestDto)
+    });
+};
+exports.internalSessionLaunchControllerApplyControlBundle = internalSessionLaunchControllerApplyControlBundle;
+/**
+ * @summary Launch step — apply the workspace bootstrap + provision phase
+ */
+const getInternalSessionLaunchControllerApplyBootstrapUrl = (sessionId) => {
+    return `/internal/sessions/${sessionId}/launch/apply-bootstrap`;
+};
+exports.getInternalSessionLaunchControllerApplyBootstrapUrl = getInternalSessionLaunchControllerApplyBootstrapUrl;
+const internalSessionLaunchControllerApplyBootstrap = async (sessionId, launchStepRequestDto, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getInternalSessionLaunchControllerApplyBootstrapUrl)(sessionId), {
+        ...options,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(launchStepRequestDto)
+    });
+};
+exports.internalSessionLaunchControllerApplyBootstrap = internalSessionLaunchControllerApplyBootstrap;
+/**
+ * @summary Launch step — finalize (provisioning → active)
+ */
+const getInternalSessionLaunchControllerFinalizeUrl = (sessionId) => {
+    return `/internal/sessions/${sessionId}/launch/finalize`;
+};
+exports.getInternalSessionLaunchControllerFinalizeUrl = getInternalSessionLaunchControllerFinalizeUrl;
+const internalSessionLaunchControllerFinalize = async (sessionId, launchStepRequestDto, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getInternalSessionLaunchControllerFinalizeUrl)(sessionId), {
+        ...options,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(launchStepRequestDto)
+    });
+};
+exports.internalSessionLaunchControllerFinalize = internalSessionLaunchControllerFinalize;
+/**
+ * @summary Launch compensation — release the allocation, drive the session to failed
+ */
+const getInternalSessionLaunchControllerFailUrl = (sessionId) => {
+    return `/internal/sessions/${sessionId}/launch/fail`;
+};
+exports.getInternalSessionLaunchControllerFailUrl = getInternalSessionLaunchControllerFailUrl;
+const internalSessionLaunchControllerFail = async (sessionId, launchFailRequestDto, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getInternalSessionLaunchControllerFailUrl)(sessionId), {
+        ...options,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(launchFailRequestDto)
+    });
+};
+exports.internalSessionLaunchControllerFail = internalSessionLaunchControllerFail;
+/**
+ * @summary Resume step — re-acquire, restore, recovering → active
+ */
+const getInternalSessionLifecycleStepControllerResumeRunUrl = (sessionId) => {
+    return `/internal/sessions/${sessionId}/resume/run`;
+};
+exports.getInternalSessionLifecycleStepControllerResumeRunUrl = getInternalSessionLifecycleStepControllerResumeRunUrl;
+const internalSessionLifecycleStepControllerResumeRun = async (sessionId, launchStepRequestDto, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getInternalSessionLifecycleStepControllerResumeRunUrl)(sessionId), {
+        ...options,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(launchStepRequestDto)
+    });
+};
+exports.internalSessionLifecycleStepControllerResumeRun = internalSessionLifecycleStepControllerResumeRun;
+/**
+ * @summary Resume compensation — roll the session back to paused
+ */
+const getInternalSessionLifecycleStepControllerResumeFailUrl = (sessionId) => {
+    return `/internal/sessions/${sessionId}/resume/fail`;
+};
+exports.getInternalSessionLifecycleStepControllerResumeFailUrl = getInternalSessionLifecycleStepControllerResumeFailUrl;
+const internalSessionLifecycleStepControllerResumeFail = async (sessionId, launchStepRequestDto, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getInternalSessionLifecycleStepControllerResumeFailUrl)(sessionId), {
+        ...options,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(launchStepRequestDto)
+    });
+};
+exports.internalSessionLifecycleStepControllerResumeFail = internalSessionLifecycleStepControllerResumeFail;
+/**
+ * @summary Hibernate step — snapshot, release worker, active → paused
+ */
+const getInternalSessionLifecycleStepControllerHibernateRunUrl = (sessionId) => {
+    return `/internal/sessions/${sessionId}/hibernate/run`;
+};
+exports.getInternalSessionLifecycleStepControllerHibernateRunUrl = getInternalSessionLifecycleStepControllerHibernateRunUrl;
+const internalSessionLifecycleStepControllerHibernateRun = async (sessionId, launchStepRequestDto, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getInternalSessionLifecycleStepControllerHibernateRunUrl)(sessionId), {
+        ...options,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(launchStepRequestDto)
+    });
+};
+exports.internalSessionLifecycleStepControllerHibernateRun = internalSessionLifecycleStepControllerHibernateRun;
+/**
+ * @summary Hibernate compensation — force-pause a session whose snapshot failed after retries exhausted (worker permanently dead). Transitions active → paused without a new snapshot so the idle monitor stops retrying.
+ */
+const getInternalSessionLifecycleStepControllerHibernateForcePauseUrl = (sessionId) => {
+    return `/internal/sessions/${sessionId}/hibernate/force-pause`;
+};
+exports.getInternalSessionLifecycleStepControllerHibernateForcePauseUrl = getInternalSessionLifecycleStepControllerHibernateForcePauseUrl;
+const internalSessionLifecycleStepControllerHibernateForcePause = async (sessionId, launchStepRequestDto, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getInternalSessionLifecycleStepControllerHibernateForcePauseUrl)(sessionId), {
+        ...options,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(launchStepRequestDto)
+    });
+};
+exports.internalSessionLifecycleStepControllerHibernateForcePause = internalSessionLifecycleStepControllerHibernateForcePause;
+/**
+ * Service-to-service endpoint fired by the session-lifecycle-reconcile Temporal Schedule. (Re)starts launch workflows for sessions stranded in creating/provisioning.
+ * @summary Run one session-lifecycle reconcile sweep
+ */
+const getInternalSessionLifecycleReconcileControllerReconcileTickUrl = () => {
+    return `/internal/session-lifecycle/reconcile-tick`;
+};
+exports.getInternalSessionLifecycleReconcileControllerReconcileTickUrl = getInternalSessionLifecycleReconcileControllerReconcileTickUrl;
+const internalSessionLifecycleReconcileControllerReconcileTick = async (options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getInternalSessionLifecycleReconcileControllerReconcileTickUrl)(), {
+        ...options,
+        method: 'POST'
+    });
+};
+exports.internalSessionLifecycleReconcileControllerReconcileTick = internalSessionLifecycleReconcileControllerReconcileTick;
+/**
+ * Service-to-service endpoint fired by the session-checkpoint Temporal Schedule. Snapshots every active session to blob storage for crash recovery; an all-sessions-failed sweep throws so the activity retries.
+ * @summary Run one session-checkpoint sweep
+ */
+const getInternalSessionCheckpointControllerCheckpointTickUrl = () => {
+    return `/internal/session-checkpoint/checkpoint-tick`;
+};
+exports.getInternalSessionCheckpointControllerCheckpointTickUrl = getInternalSessionCheckpointControllerCheckpointTickUrl;
+const internalSessionCheckpointControllerCheckpointTick = async (options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getInternalSessionCheckpointControllerCheckpointTickUrl)(), {
+        ...options,
+        method: 'POST'
+    });
+};
+exports.internalSessionCheckpointControllerCheckpointTick = internalSessionCheckpointControllerCheckpointTick;
+/**
+ * Service-to-service endpoint fired by the backfillSessionCompositionRefWorkflow once per batch. Scans up to `batchSize` pre-Phase-6 sessions, ensures a Composition exists in llm-registry-api per content-bucket, and stamps `composition_ref` on each session. Idempotent: the SQL UPDATE is guarded by `composition_ref IS NULL` so a concurrent tick is a no-op.
+ * @summary Run one batch of the session-composition-ref backfill
+ */
+const getInternalBackfillsControllerRunCompositionRefBatchUrl = () => {
+    return `/internal/backfills/session-composition-ref/run-batch`;
+};
+exports.getInternalBackfillsControllerRunCompositionRefBatchUrl = getInternalBackfillsControllerRunCompositionRefBatchUrl;
+const internalBackfillsControllerRunCompositionRefBatch = async (runBackfillBatchRequestDto, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getInternalBackfillsControllerRunCompositionRefBatchUrl)(), {
+        ...options,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(runBackfillBatchRequestDto)
+    });
+};
+exports.internalBackfillsControllerRunCompositionRefBatch = internalBackfillsControllerRunCompositionRefBatch;
+/**
+ * Service-to-service endpoint fired by the sweeperSandboxSessionWorkflow Temporal Schedule. Disposes every live sandbox session whose `sandboxExpiresAt` has elapsed.
+ * @summary Run one sandbox-session TTL sweep
+ */
+const getInternalSweepersControllerSandboxSessionTickUrl = () => {
+    return `/internal/sweepers/sandbox-session/tick`;
+};
+exports.getInternalSweepersControllerSandboxSessionTickUrl = getInternalSweepersControllerSandboxSessionTickUrl;
+const internalSweepersControllerSandboxSessionTick = async (options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getInternalSweepersControllerSandboxSessionTickUrl)(), {
+        ...options,
+        method: 'POST'
+    });
+};
+exports.internalSweepersControllerSandboxSessionTick = internalSweepersControllerSandboxSessionTick;

package/dist/endpoints/internal-session-dispatch/internal-session-dispatch.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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 { DispatchEnvelopeDto, InputsAppendEnvelopeDto } from '../../models';
+/**
+ * `create_and_run` mints a new Session row, waits for provisioning, drives one turn, then pauses. `resume_and_run` resumes an existing paused session, seeds `revisionInputs` into `/workspace/inputs/`, drives one turn, then pauses.
+ * @summary Dispatch one agent turn on a pipeline-owned session and pause afterward.
+ */
+export declare const getInternalSessionDispatchControllerDispatchTurnUrl: () => string;
+export declare const internalSessionDispatchControllerDispatchTurn: (dispatchEnvelopeDto: DispatchEnvelopeDto, options?: RequestInit) => Promise<void>;
+/**
+ * Out-of-band write into a session's inputs slot. The session must have a live allocation — callers resume the session first. Used by UI uploads and integration tests that need to seed inputs without driving a turn.
+ * @summary Append one file into a live session's `/workspace/inputs/` slot.
+ */
+export declare const getInternalSessionDispatchControllerAppendInputsUrl: (id: string) => string;
+export declare const internalSessionDispatchControllerAppendInputs: (id: string, inputsAppendEnvelopeDto: InputsAppendEnvelopeDto, options?: RequestInit) => Promise<void>;

package/dist/endpoints/internal-session-dispatch/internal-session-dispatch.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.internalSessionDispatchControllerAppendInputs = exports.getInternalSessionDispatchControllerAppendInputsUrl = exports.internalSessionDispatchControllerDispatchTurn = exports.getInternalSessionDispatchControllerDispatchTurnUrl = void 0;
+const custom_fetch_1 = require("../../custom-fetch");
+/**
+ * `create_and_run` mints a new Session row, waits for provisioning, drives one turn, then pauses. `resume_and_run` resumes an existing paused session, seeds `revisionInputs` into `/workspace/inputs/`, drives one turn, then pauses.
+ * @summary Dispatch one agent turn on a pipeline-owned session and pause afterward.
+ */
+const getInternalSessionDispatchControllerDispatchTurnUrl = () => {
+    return `/internal/sessions/dispatch`;
+};
+exports.getInternalSessionDispatchControllerDispatchTurnUrl = getInternalSessionDispatchControllerDispatchTurnUrl;
+const internalSessionDispatchControllerDispatchTurn = async (dispatchEnvelopeDto, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getInternalSessionDispatchControllerDispatchTurnUrl)(), {
+        ...options,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(dispatchEnvelopeDto)
+    });
+};
+exports.internalSessionDispatchControllerDispatchTurn = internalSessionDispatchControllerDispatchTurn;
+/**
+ * Out-of-band write into a session's inputs slot. The session must have a live allocation — callers resume the session first. Used by UI uploads and integration tests that need to seed inputs without driving a turn.
+ * @summary Append one file into a live session's `/workspace/inputs/` slot.
+ */
+const getInternalSessionDispatchControllerAppendInputsUrl = (id) => {
+    return `/internal/sessions/${id}/inputs/append`;
+};
+exports.getInternalSessionDispatchControllerAppendInputsUrl = getInternalSessionDispatchControllerAppendInputsUrl;
+const internalSessionDispatchControllerAppendInputs = async (id, inputsAppendEnvelopeDto, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getInternalSessionDispatchControllerAppendInputsUrl)(id), {
+        ...options,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(inputsAppendEnvelopeDto)
+    });
+};
+exports.internalSessionDispatchControllerAppendInputs = internalSessionDispatchControllerAppendInputs;

package/dist/endpoints/output-surface-inspect/output-surface-inspect.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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 { ReportInspectPresenceDto, ReportInspectResultDto } from '../../models';
+/**
+ * @summary Relay an Output Surface Inspector step result from the output surface iframe back to the broker.
+ */
+export declare const getOutputSurfaceInspectControllerResultUrl: (id: string) => string;
+export declare const outputSurfaceInspectControllerResult: (id: string, reportInspectResultDto: ReportInspectResultDto, options?: RequestInit) => Promise<unknown>;
+/**
+ * @summary Report output-surface-tab presence and bridge lifecycle (attach / heartbeat / detach / hello / unloading).
+ */
+export declare const getOutputSurfaceInspectControllerPresenceUrl: (id: string) => string;
+export declare const outputSurfaceInspectControllerPresence: (id: string, reportInspectPresenceDto: ReportInspectPresenceDto, options?: RequestInit) => Promise<unknown>;

package/dist/endpoints/output-surface-inspect/output-surface-inspect.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.outputSurfaceInspectControllerPresence = exports.getOutputSurfaceInspectControllerPresenceUrl = exports.outputSurfaceInspectControllerResult = exports.getOutputSurfaceInspectControllerResultUrl = void 0;
+const custom_fetch_1 = require("../../custom-fetch");
+/**
+ * @summary Relay an Output Surface Inspector step result from the output surface iframe back to the broker.
+ */
+const getOutputSurfaceInspectControllerResultUrl = (id) => {
+    return `/sessions/${id}/output-surface-inspect/result`;
+};
+exports.getOutputSurfaceInspectControllerResultUrl = getOutputSurfaceInspectControllerResultUrl;
+const outputSurfaceInspectControllerResult = async (id, reportInspectResultDto, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getOutputSurfaceInspectControllerResultUrl)(id), {
+        ...options,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(reportInspectResultDto)
+    });
+};
+exports.outputSurfaceInspectControllerResult = outputSurfaceInspectControllerResult;
+/**
+ * @summary Report output-surface-tab presence and bridge lifecycle (attach / heartbeat / detach / hello / unloading).
+ */
+const getOutputSurfaceInspectControllerPresenceUrl = (id) => {
+    return `/sessions/${id}/output-surface-inspect/presence`;
+};
+exports.getOutputSurfaceInspectControllerPresenceUrl = getOutputSurfaceInspectControllerPresenceUrl;
+const outputSurfaceInspectControllerPresence = async (id, reportInspectPresenceDto, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getOutputSurfaceInspectControllerPresenceUrl)(id), {
+        ...options,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(reportInspectPresenceDto)
+    });
+};
+exports.outputSurfaceInspectControllerPresence = outputSurfaceInspectControllerPresence;

package/dist/endpoints/output-surfaces/output-surfaces.d.ts

@@ -0,0 +1,43 @@
+/**
+ * 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 { OutputSurfaceAppResponseDtoDataArrayEnvelope, OutputSurfaceAppResponseDtoDataEnvelope, OutputSurfaceControllerRestartParams, OutputSurfaceControllerScanParams, RemediateOutputSurfaceDto, RemediateOutputSurfaceResponseDtoDataEnvelope, RotateTokenResponseDtoDataEnvelope } from '../../models';
+/**
+ * @summary List runnable output surface apps for this session.
+ */
+export declare const getOutputSurfaceControllerListAppsUrl: (id: string) => string;
+export declare const outputSurfaceControllerListApps: (id: string, options?: RequestInit) => Promise<OutputSurfaceAppResponseDtoDataArrayEnvelope>;
+/**
+ * @summary Request the worker to rescan the workspace for runnable apps.
+ */
+export declare const getOutputSurfaceControllerScanUrl: (id: string, params?: OutputSurfaceControllerScanParams) => string;
+export declare const outputSurfaceControllerScan: (id: string, params?: OutputSurfaceControllerScanParams, options?: RequestInit) => Promise<unknown>;
+/**
+ * @summary Hard-restart an output surface app (stop then spawn).
+ */
+export declare const getOutputSurfaceControllerRestartUrl: (id: string, appId: string, params?: OutputSurfaceControllerRestartParams) => string;
+export declare const outputSurfaceControllerRestart: (id: string, appId: string, params?: OutputSurfaceControllerRestartParams, options?: RequestInit) => Promise<OutputSurfaceAppResponseDtoDataEnvelope>;
+/**
+ * @summary Stream stdout/stderr from the running output surface app as Server-Sent Events. Each frame is `data: {"seq","ts","stream","line"}\n\n`. The stream stays open until the client disconnects or the worker stops the app; closing the client connection aborts the upstream subscription on the worker.
+ */
+export declare const getOutputSurfaceControllerStreamLogsUrl: (id: string, appId: string) => string;
+export declare const outputSurfaceControllerStreamLogs: (id: string, appId: string, options?: RequestInit) => Promise<unknown>;
+/**
+ * @summary Stop an output surface app and release its port.
+ */
+export declare const getOutputSurfaceControllerStopUrl: (id: string, appId: string) => string;
+export declare const outputSurfaceControllerStop: (id: string, appId: string, options?: RequestInit) => Promise<unknown>;
+/**
+ * @summary Dispatch an agent remediation for a stuck output-surface app (install_failed / declaration_needed / crashed / stopped). The server reads the current SessionOutputSurfaceApp row as source of truth — status, kind, port, lastError, install metadata — and validates `status` matches the requested `remediationKind` (409 otherwise). Renders a templated prompt that includes the runtime port contract + per-kind cheatsheet, then injects it into the opencode session as a user message. The agent is instructed to edit files and then call the `output_surface_rescan` MCP tool — it must NOT run install or dev commands directly.
+ */
+export declare const getOutputSurfaceControllerRemediateUrl: (id: string) => string;
+export declare const outputSurfaceControllerRemediate: (id: string, remediateOutputSurfaceDto: RemediateOutputSurfaceDto, options?: RequestInit) => Promise<RemediateOutputSurfaceResponseDtoDataEnvelope>;
+/**
+ * @summary Revoke the current share token and mint a new one; updates the external URL.
+ */
+export declare const getOutputSurfaceControllerRotateTokenUrl: (id: string, appId: string) => string;
+export declare const outputSurfaceControllerRotateToken: (id: string, appId: string, options?: RequestInit) => Promise<RotateTokenResponseDtoDataEnvelope>;

package/dist/endpoints/output-surfaces/output-surfaces.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.outputSurfaceControllerRotateToken = exports.getOutputSurfaceControllerRotateTokenUrl = exports.outputSurfaceControllerRemediate = exports.getOutputSurfaceControllerRemediateUrl = exports.outputSurfaceControllerStop = exports.getOutputSurfaceControllerStopUrl = exports.outputSurfaceControllerStreamLogs = exports.getOutputSurfaceControllerStreamLogsUrl = exports.outputSurfaceControllerRestart = exports.getOutputSurfaceControllerRestartUrl = exports.outputSurfaceControllerScan = exports.getOutputSurfaceControllerScanUrl = exports.outputSurfaceControllerListApps = exports.getOutputSurfaceControllerListAppsUrl = void 0;
+const custom_fetch_1 = require("../../custom-fetch");
+/**
+ * @summary List runnable output surface apps for this session.
+ */
+const getOutputSurfaceControllerListAppsUrl = (id) => {
+    return `/sessions/${id}/output-surfaces/apps`;
+};
+exports.getOutputSurfaceControllerListAppsUrl = getOutputSurfaceControllerListAppsUrl;
+const outputSurfaceControllerListApps = async (id, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getOutputSurfaceControllerListAppsUrl)(id), {
+        ...options,
+        method: 'GET'
+    });
+};
+exports.outputSurfaceControllerListApps = outputSurfaceControllerListApps;
+/**
+ * @summary Request the worker to rescan the workspace for runnable apps.
+ */
+const getOutputSurfaceControllerScanUrl = (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}/output-surfaces/scan?${stringifiedParams}` : `/sessions/${id}/output-surfaces/scan`;
+};
+exports.getOutputSurfaceControllerScanUrl = getOutputSurfaceControllerScanUrl;
+const outputSurfaceControllerScan = async (id, params, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getOutputSurfaceControllerScanUrl)(id, params), {
+        ...options,
+        method: 'POST'
+    });
+};
+exports.outputSurfaceControllerScan = outputSurfaceControllerScan;
+/**
+ * @summary Hard-restart an output surface app (stop then spawn).
+ */
+const getOutputSurfaceControllerRestartUrl = (id, appId, 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}/output-surfaces/apps/${appId}/restart?${stringifiedParams}` : `/sessions/${id}/output-surfaces/apps/${appId}/restart`;
+};
+exports.getOutputSurfaceControllerRestartUrl = getOutputSurfaceControllerRestartUrl;
+const outputSurfaceControllerRestart = async (id, appId, params, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getOutputSurfaceControllerRestartUrl)(id, appId, params), {
+        ...options,
+        method: 'POST'
+    });
+};
+exports.outputSurfaceControllerRestart = outputSurfaceControllerRestart;
+/**
+ * @summary Stream stdout/stderr from the running output surface app as Server-Sent Events. Each frame is `data: {"seq","ts","stream","line"}\n\n`. The stream stays open until the client disconnects or the worker stops the app; closing the client connection aborts the upstream subscription on the worker.
+ */
+const getOutputSurfaceControllerStreamLogsUrl = (id, appId) => {
+    return `/sessions/${id}/output-surfaces/apps/${appId}/logs`;
+};
+exports.getOutputSurfaceControllerStreamLogsUrl = getOutputSurfaceControllerStreamLogsUrl;
+const outputSurfaceControllerStreamLogs = async (id, appId, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getOutputSurfaceControllerStreamLogsUrl)(id, appId), {
+        ...options,
+        method: 'GET'
+    });
+};
+exports.outputSurfaceControllerStreamLogs = outputSurfaceControllerStreamLogs;
+/**
+ * @summary Stop an output surface app and release its port.
+ */
+const getOutputSurfaceControllerStopUrl = (id, appId) => {
+    return `/sessions/${id}/output-surfaces/apps/${appId}/stop`;
+};
+exports.getOutputSurfaceControllerStopUrl = getOutputSurfaceControllerStopUrl;
+const outputSurfaceControllerStop = async (id, appId, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getOutputSurfaceControllerStopUrl)(id, appId), {
+        ...options,
+        method: 'POST'
+    });
+};
+exports.outputSurfaceControllerStop = outputSurfaceControllerStop;
+/**
+ * @summary Dispatch an agent remediation for a stuck output-surface app (install_failed / declaration_needed / crashed / stopped). The server reads the current SessionOutputSurfaceApp row as source of truth — status, kind, port, lastError, install metadata — and validates `status` matches the requested `remediationKind` (409 otherwise). Renders a templated prompt that includes the runtime port contract + per-kind cheatsheet, then injects it into the opencode session as a user message. The agent is instructed to edit files and then call the `output_surface_rescan` MCP tool — it must NOT run install or dev commands directly.
+ */
+const getOutputSurfaceControllerRemediateUrl = (id) => {
+    return `/sessions/${id}/output-surfaces/remediate`;
+};
+exports.getOutputSurfaceControllerRemediateUrl = getOutputSurfaceControllerRemediateUrl;
+const outputSurfaceControllerRemediate = async (id, remediateOutputSurfaceDto, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getOutputSurfaceControllerRemediateUrl)(id), {
+        ...options,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(remediateOutputSurfaceDto)
+    });
+};
+exports.outputSurfaceControllerRemediate = outputSurfaceControllerRemediate;
+/**
+ * @summary Revoke the current share token and mint a new one; updates the external URL.
+ */
+const getOutputSurfaceControllerRotateTokenUrl = (id, appId) => {
+    return `/sessions/${id}/output-surfaces/apps/${appId}/token/rotate`;
+};
+exports.getOutputSurfaceControllerRotateTokenUrl = getOutputSurfaceControllerRotateTokenUrl;
+const outputSurfaceControllerRotateToken = async (id, appId, options) => {
+    return (0, custom_fetch_1.customFetch)((0, exports.getOutputSurfaceControllerRotateTokenUrl)(id, appId), {
+        ...options,
+        method: 'POST'
+    });
+};
+exports.outputSurfaceControllerRotateToken = outputSurfaceControllerRotateToken;

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

@@ -0,0 +1,43 @@
+/**
+ * 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 { CreateSandboxSessionDto, RunSandboxEvalTurnDto, SandboxEvalTurnResultDtoDataEnvelope, SandboxSessionsControllerDeleteToolMocksParams, SandboxToolMocksResponseDtoDataEnvelope, SessionDebugInfoDtoDataEnvelope, SessionResponseDtoDataEnvelope, SetSandboxToolMocksDto } from '../../models';
+/**
+ * @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.
+ */
+export declare const getSandboxSessionsControllerCreateUrl: () => string;
+export declare const sandboxSessionsControllerCreate: (createSandboxSessionDto: CreateSandboxSessionDto, options?: RequestInit) => Promise<SessionResponseDtoDataEnvelope>;
+/**
+ * @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.
+ */
+export declare const getSandboxSessionsControllerSetToolMocksUrl: (id: string) => string;
+export declare const sandboxSessionsControllerSetToolMocks: (id: string, setSandboxToolMocksDto: SetSandboxToolMocksDto, options?: RequestInit) => Promise<SandboxToolMocksResponseDtoDataEnvelope>;
+/**
+ * @summary List the canonical tool names a sandbox session currently has canned mock responses registered for.
+ */
+export declare const getSandboxSessionsControllerListToolMocksUrl: (id: string) => string;
+export declare const sandboxSessionsControllerListToolMocks: (id: string, options?: RequestInit) => Promise<SandboxToolMocksResponseDtoDataEnvelope>;
+/**
+ * @summary Delete one mocked tool from a sandbox session, or every mock for the session when the `toolName` query parameter is omitted.
+ */
+export declare const getSandboxSessionsControllerDeleteToolMocksUrl: (id: string, params?: SandboxSessionsControllerDeleteToolMocksParams) => string;
+export declare const sandboxSessionsControllerDeleteToolMocks: (id: string, params?: SandboxSessionsControllerDeleteToolMocksParams, options?: RequestInit) => Promise<unknown>;
+/**
+ * @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.
+ */
+export declare const getSandboxSessionsControllerRunEvalTurnUrl: (id: string) => string;
+export declare const sandboxSessionsControllerRunEvalTurn: (id: string, runSandboxEvalTurnDto: RunSandboxEvalTurnDto, options?: RequestInit) => Promise<SandboxEvalTurnResultDtoDataEnvelope>;
+/**
+ * @summary Dispose a sandbox session — release its worker and drive it terminal. Idempotent.
+ */
+export declare const getSandboxSessionsControllerDisposeUrl: (id: string) => string;
+export declare const sandboxSessionsControllerDispose: (id: string, options?: RequestInit) => Promise<SessionResponseDtoDataEnvelope>;
+/**
+ * @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.
+ */
+export declare const getSandboxSessionsControllerDebugUrl: (id: string) => string;
+export declare const sandboxSessionsControllerDebug: (id: string, options?: RequestInit) => Promise<SessionDebugInfoDtoDataEnvelope>;