Sessions
98 methods on the Sessions resource.
98 methods · 87 available to app tokens36 pages in SDK Reference
import { Compozy } from "@compozy/client";98 of 98
addSessionWorkLinkanswerSessionClarificationapproveSessionarchiveSessionattachSessionbindSessionWorktreecancelQueuedSessionPromptcancelSessionMonitorcancelSessionPromptcancelSubagentclearSessionConversationclearSessionInputsclearSessionParentclearSessionRuntimecompactSessioncontinueSessioncreateSessioncreateSessionFolderdeleteSessiondeleteSessionAttachmentdeleteSessionFolderforkSessionforkSessionToWorktreegetGlobalSessionHistorygetGlobalSessionStatusgetGlobalSessionTranscriptgetGlobalSessionTranscriptOutlinegetSessiongetSessionAttentionSummarygetSessionByIDgetSessionCommandsgetSessionHealthgetSessionHistorygetSessionOwnergetSessionRecapgetSessionStatusgetSessionTranscriptgetSessionTranscriptOutlinegetSessionUsagegetSessionUsageTurnsgetSubagentinspectSessionlistGlobalSessionEventslistProcesseslistSessionClarificationslistSessionDescendantslistSessionEventslistSessionFacetslistSessionFolderslistSessionInputslistSessionInteractionslistSessionLinkedWorklistSessionMonitorslistSessionPendingInteractionslistSessionProcesseslistSessionSubagentslistSessionToolslistSessionslistWorkspaceSessionsmarkSessionSeenmoveSessionmoveSessionToLatermoveSessionToProfilepreviewSessionDerivepromoteSessionInputreadSessionAttachmentBytesrefreshSessionPullRequestrefreshSessionSoulrefreshSessionWorkLinkremoveSessionWorkLinkrenameSessionrenameSessionFolderreorderSessionFoldersreorderSessionsrepairSessionreplaceSessionInputresumeSessionFromLaterrewindSessionConversationsearchGlobalSessionTranscriptsearchSessionFilessearchSessionToolssearchSessionTranscriptsearchSessionWorkCandidatespromptpromptsetSessionParentsetSessionRuntimesteerSessionPromptstopSessionstreamGlobalSessionssestreamSessionssestreamSessionCatalogsseterminateProcessesterminateSessionProcessesunarchiveSessionunbindSessionWorktreeupdateSessionPresenceuploadSessionAttachmentwaitForSession
addSessionWorkLink
Link work to a session
compozy.sessions.addSessionWorkLink({ path, query, body }) → Promise<SessionLinkedWorkResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Act as this profile by name
Request bodySessionWorkLinkRequest
POST /api/workspaces/{workspace_id}/sessions/{session_id}/linksapp tokens denied
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.addSessionWorkLink({ path: { "workspace_id": "workspace_id", "session_id": "session_id" }, body: { /* request fields */ } });answerSessionClarification
Answer a live session clarification
compozy.sessions.answerSessionClarification({ path, query, body }) → Promise<ClarifyAnswer>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- request_idstringpathrequired
- Clarification request id
- profilestringquery
- Act as this profile by name
Request bodyClarificationAnswerRequest
POST /api/workspaces/{workspace_id}/sessions/{session_id}/clarifications/{request_id}/answerapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.answerSessionClarification({ path: { "workspace_id": "workspace_id", "session_id": "session_id", "request_id": "request_id" }, body: { /* request fields */ } });approveSession
Approve or deny an interactive permission request
compozy.sessions.approveSession({ path, query, body }) → Promise<SessionApprovalResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Act as this profile by name
Request bodyApproveSessionRequest
POST /api/workspaces/{workspace_id}/sessions/{session_id}/approveapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.approveSession({ path: { "workspace_id": "workspace_id", "session_id": "session_id" }, body: { /* request fields */ } });archiveSession
Archive a stopped session, or stop and archive a live session with stop=true
compozy.sessions.archiveSession({ path, query }) → Promise<SessionResponse>
Options
- processes"keep" | "terminate"query
- Keep (default) or terminate attributed session processes
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- stopbooleanquery
- Stop a live session through the normal stop path before archiving it; a failed stop leaves it unarchived
- with_childrenbooleanquery
- Also archive the session's child sessions, recursively, in one transaction; with stop=true their live members stop first and a failed stop archives nothing
- profilestringquery
- Act as this profile by name
POST /api/workspaces/{workspace_id}/sessions/{session_id}/archiveapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.archiveSession({ path: { "workspace_id": "workspace_id", "session_id": "session_id" } });attachSession
Attach to a resumable live session
compozy.sessions.attachSession({ path, query, body }) → Promise<SessionAttachResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Act as this profile by name
Request bodyAttachSessionRequest
POST /api/workspaces/{workspace_id}/sessions/{session_id}/attachapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.attachSession({ path: { "workspace_id": "workspace_id", "session_id": "session_id" }, body: { /* request fields */ } });bindSessionWorktree
Bind an idle existing session to a ready worktree in place
compozy.sessions.bindSessionWorktree({ path, query, body }) → Promise<SessionResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Act as this profile by name
Request bodyBindSessionWorktreeRequest
PUT /api/workspaces/{workspace_id}/sessions/{session_id}/worktreeapp tokens denied
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.bindSessionWorktree({ path: { "workspace_id": "workspace_id", "session_id": "session_id" }, body: { /* request fields */ } });cancelQueuedSessionPrompt
Cancel a queued session prompt entry
compozy.sessions.cancelQueuedSessionPrompt({ path, query }) → Promise<SendPromptResultResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- queue_entry_idstringpathrequired
- Queue entry id
- profilestringquery
- Act as this profile by name
DELETE /api/workspaces/{workspace_id}/sessions/{session_id}/prompt/queue/{queue_entry_id}app tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.cancelQueuedSessionPrompt({ path: { "workspace_id": "workspace_id", "session_id": "session_id", "queue_entry_id": "queue_entry_id" } });cancelSessionMonitor
Cancel a session monitor without waking the session
compozy.sessions.cancelSessionMonitor({ path, query }) → Promise<SessionMonitorResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- monitor_idstringpathrequired
- Monitor id
- profilestringquery
- Act as this profile by name
POST /api/workspaces/{workspace_id}/sessions/{session_id}/monitors/{monitor_id}/cancelapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.cancelSessionMonitor({ path: { "workspace_id": "workspace_id", "session_id": "session_id", "monitor_id": "monitor_id" } });cancelSessionPrompt
Cancel the active session prompt
compozy.sessions.cancelSessionPrompt({ path, query }) → Promise<SessionPromptCancelResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Act as this profile by name
POST /api/workspaces/{workspace_id}/sessions/{session_id}/prompt/cancelapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.cancelSessionPrompt({ path: { "workspace_id": "workspace_id", "session_id": "session_id" } });cancelSubagent
Cancel a delegated subagent
compozy.sessions.cancelSubagent({ path, query, body }) → Promise<SubagentCancelPayload>
Options
- workspace_idstringpathrequired
- Workspace id
- subagent_idstringpathrequired
- Subagent id
- profilestringquery
- Act as this profile by name
Request bodySubagentCancelRequest
POST /api/workspaces/{workspace_id}/subagents/{subagent_id}/cancelapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.cancelSubagent({ path: { "workspace_id": "workspace_id", "subagent_id": "subagent_id" }, body: { /* request fields */ } });Show all 98 methods
clearSessionConversation
Clear conversation history and restart the session context
compozy.sessions.clearSessionConversation({ path, query }) → Promise<SessionResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Act as this profile by name
POST /api/workspaces/{workspace_id}/sessions/{session_id}/clearapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.clearSessionConversation({ path: { "workspace_id": "workspace_id", "session_id": "session_id" } });clearSessionInputs
Clear queued input with attributed per-entry traces
compozy.sessions.clearSessionInputs({ path, query }) → Promise<SessionInputClearResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Act as this profile by name
DELETE /api/workspaces/{workspace_id}/sessions/{session_id}/prompt/queueapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.clearSessionInputs({ path: { "workspace_id": "workspace_id", "session_id": "session_id" } });clearSessionParent
Make an adopted child session top-level, or take over a stopped spawned worker
compozy.sessions.clearSessionParent({ path, query }) → Promise<SessionResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Act as this profile by name
DELETE /api/workspaces/{workspace_id}/sessions/{session_id}/parentapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.clearSessionParent({ path: { "workspace_id": "workspace_id", "session_id": "session_id" } });clearSessionRuntime
Clear the default runtime for future prompts
compozy.sessions.clearSessionRuntime({ path, query }) → Promise<SessionResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- expected_revisionintegerqueryrequired
- Current runtime selection revision
- profilestringquery
- Act as this profile by name
DELETE /api/workspaces/{workspace_id}/sessions/{session_id}/runtimeapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.clearSessionRuntime({ path: { "workspace_id": "workspace_id", "session_id": "session_id" }, query: { "expected_revision": 1 } });compactSession
Request advertised native agent compaction (experimental)
compozy.sessions.compactSession({ path, query, body }) → Promise<SessionCompactResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Act as this profile by name
Request bodySessionCompactRequest
POST /api/workspaces/{workspace_id}/sessions/{session_id}/compactapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.compactSession({ path: { "workspace_id": "workspace_id", "session_id": "session_id" }, body: { /* request fields */ } });continueSession
Continue a session with another agent, runtime, or declared route
compozy.sessions.continueSession({ path, query, body }) → Promise<ContinueSessionResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Source session id
- profilestringquery
- Act as this profile by name
Request bodyContinueSessionRequest
POST /api/workspaces/{workspace_id}/sessions/{session_id}/continueapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.continueSession({ path: { "workspace_id": "workspace_id", "session_id": "session_id" }, body: { /* request fields */ } });createSession
Create a session
compozy.sessions.createSession({ query, body }) → Promise<SessionResponse>
Options
- profilestringquery
- Act as this profile by name
Request bodyCreateSessionRequest
POST /api/sessionsapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.createSession({ body: { /* request fields */ } });createSessionFolder
Create a session folder
compozy.sessions.createSessionFolder({ path, query, body }) → Promise<SessionFolderResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- profilestringquery
- Act as this profile by name
Request bodyCreateSessionFolderRequest
POST /api/workspaces/{workspace_id}/session-foldersapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.createSessionFolder({ path: { "workspace_id": "workspace_id" }, body: { /* request fields */ } });deleteSession
Delete one session and remove it from persisted history
compozy.sessions.deleteSession({ path, query }) → Promise<void>
Options
- processes"keep" | "terminate"query
- Keep (default) or terminate attributed session processes
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- with_childrenbooleanquery
- Also delete the session's child sessions, recursively, deepest first; a failure leaves the rest in place
- profilestringquery
- Act as this profile by name
DELETE /api/workspaces/{workspace_id}/sessions/{session_id}app tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.deleteSession({ path: { "workspace_id": "workspace_id", "session_id": "session_id" } });deleteSessionAttachment
Delete a session attachment
compozy.sessions.deleteSessionAttachment({ path, query }) → Promise<void>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- attachment_idstringpathrequired
- Attachment id
- profilestringquery
- Act as this profile by name
DELETE /api/workspaces/{workspace_id}/sessions/{session_id}/attachments/{attachment_id}app tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.deleteSessionAttachment({ path: { "workspace_id": "workspace_id", "session_id": "session_id", "attachment_id": "attachment_id" } });deleteSessionFolder
Delete a session folder; its sessions return to the workspace root
compozy.sessions.deleteSessionFolder({ path, query }) → Promise<SessionFoldersResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- folder_idstringpathrequired
- Session folder id
- profilestringquery
- Act as this profile by name
DELETE /api/workspaces/{workspace_id}/session-folders/{folder_id}app tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.deleteSessionFolder({ path: { "workspace_id": "workspace_id", "folder_id": "folder_id" } });forkSession
Fork a session with the same agent, whole or through one user message and its turn
compozy.sessions.forkSession({ path, query, body }) → Promise<ForkSessionResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Source session id
- profilestringquery
- Act as this profile by name
Request bodyForkSessionRequest
POST /api/workspaces/{workspace_id}/sessions/{session_id}/forkapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.forkSession({ path: { "workspace_id": "workspace_id", "session_id": "session_id" }, body: { /* request fields */ } });forkSessionToWorktree
Fork a live session into a worktree
compozy.sessions.forkSessionToWorktree({ path, query, body }) → Promise<SessionResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Origin session id
- profilestringquery
- Act as this profile by name
Request bodyForkSessionWorktreeRequest
POST /api/workspaces/{workspace_id}/sessions/{session_id}/worktree-forkapp tokens denied
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.forkSessionToWorktree({ path: { "workspace_id": "workspace_id", "session_id": "session_id" }, body: { /* request fields */ } });getGlobalSessionHistory
List grouped session turn history for a Global session
compozy.sessions.getGlobalSessionHistory({ path, query }) → Promise<SessionHistoryResponse>
Options
- session_idstringpathrequired
- Session id
- sincestringquery
- Only events emitted since this timestamp
- limitintegerquery
- Maximum number of turns to return; defaults to the newest 200 and is capped at 1000
- after_sequenceintegerquery
- Only return events after this sequence number
- typestringquery
- Event type
- agent_namestringquery
- Agent name
- turn_idstringquery
- Turn id
- archive"active" | "archived" | "all"query
- Select active, archived, or all events
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
GET /api/sessions/{session_id}/historyapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.getGlobalSessionHistory({ path: { "session_id": "session_id" } });getGlobalSessionStatus
Read compact session status and wake eligibility for a Global session
compozy.sessions.getGlobalSessionStatus({ path, query }) → Promise<SessionStatusResponse>
Options
- session_idstringpathrequired
- Session id
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
GET /api/sessions/{session_id}/statusapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.getGlobalSessionStatus({ path: { "session_id": "session_id" } });getGlobalSessionTranscript
Get a bounded materialized transcript page for a Global session
compozy.sessions.getGlobalSessionTranscript({ path, query }) → Promise<SessionTranscriptResponse>
Options
- session_idstringpathrequired
- Session id
- limitintegerquery
- Maximum page size; defaults to the newest 200 entries and is capped at 1000
- before_sequenceintegerquery
- Return entries whose stable start sequence is before this cursor
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
GET /api/sessions/{session_id}/transcriptapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.getGlobalSessionTranscript({ path: { "session_id": "session_id" } });getGlobalSessionTranscriptOutline
Get the full retained operator-message trail with reply previews for a Global session
compozy.sessions.getGlobalSessionTranscriptOutline({ path, query }) → Promise<OutlineResult>
Options
- session_idstringpathrequired
- Session id
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
GET /api/sessions/{session_id}/transcript/outlineapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.getGlobalSessionTranscriptOutline({ path: { "session_id": "session_id" } });getSession
Get one session snapshot
compozy.sessions.getSession({ path, query }) → Promise<SessionResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- include_healthbooleanquery
- Include metadata-only session health when available
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
GET /api/workspaces/{workspace_id}/sessions/{session_id}app tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.getSession({ path: { "workspace_id": "workspace_id", "session_id": "session_id" } });getSessionAttentionSummary
Get exact session attention counts
compozy.sessions.getSessionAttentionSummary() → Promise<SessionAttentionSummaryPayload>
GET /api/sessions/attention-summaryapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.getSessionAttentionSummary();getSessionByID
Get one session snapshot by id
compozy.sessions.getSessionByID({ path, query }) → Promise<SessionResponse>
Options
- session_idstringpathrequired
- Session id
- include_healthbooleanquery
- Include metadata-only session health when available
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
GET /api/sessions/{session_id}app tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.getSessionByID({ path: { "session_id": "session_id" } });getSessionCommands
List commands available to a session
compozy.sessions.getSessionCommands({ path, query }) → Promise<SessionCommandsResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
GET /api/workspaces/{workspace_id}/sessions/{session_id}/commandsapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.getSessionCommands({ path: { "workspace_id": "workspace_id", "session_id": "session_id" } });getSessionHealth
Read metadata-only session health and wake eligibility
compozy.sessions.getSessionHealth({ path, query }) → Promise<SessionHealthResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
GET /api/workspaces/{workspace_id}/sessions/{session_id}/healthapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.getSessionHealth({ path: { "workspace_id": "workspace_id", "session_id": "session_id" } });getSessionHistory
List grouped session turn history
compozy.sessions.getSessionHistory({ path, query }) → Promise<SessionHistoryResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- sincestringquery
- Only events emitted since this timestamp
- limitintegerquery
- Maximum number of turns to return; defaults to the newest 200 and is capped at 1000
- after_sequenceintegerquery
- Only return events after this sequence number
- typestringquery
- Event type
- agent_namestringquery
- Agent name
- turn_idstringquery
- Turn id
- archive"active" | "archived" | "all"query
- Select active, archived, or all events
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
GET /api/workspaces/{workspace_id}/sessions/{session_id}/historyapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.getSessionHistory({ path: { "workspace_id": "workspace_id", "session_id": "session_id" } });getSessionOwner
Get a session owner; Global history has an empty workspace id
compozy.sessions.getSessionOwner({ path, query }) → Promise<SessionOwner>
Options
- session_idstringpathrequired
- Session id
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
GET /api/sessions/{session_id}/ownerapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.getSessionOwner({ path: { "session_id": "session_id" } });getSessionRecap
Get a deterministic session recap
compozy.sessions.getSessionRecap({ path, query }) → Promise<SessionRecapResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- limitintegerquery
- Maximum recent messages to include
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
GET /api/workspaces/{workspace_id}/sessions/{session_id}/recapapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.getSessionRecap({ path: { "workspace_id": "workspace_id", "session_id": "session_id" } });getSessionStatus
Read compact session status and wake eligibility
compozy.sessions.getSessionStatus({ path, query }) → Promise<SessionStatusResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
GET /api/workspaces/{workspace_id}/sessions/{session_id}/statusapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.getSessionStatus({ path: { "workspace_id": "workspace_id", "session_id": "session_id" } });getSessionTranscript
Get a bounded materialized transcript page
compozy.sessions.getSessionTranscript({ path, query }) → Promise<SessionTranscriptResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- limitintegerquery
- Maximum page size; defaults to the newest 200 entries and is capped at 1000
- before_sequenceintegerquery
- Return entries whose stable start sequence is before this cursor
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
GET /api/workspaces/{workspace_id}/sessions/{session_id}/transcriptapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.getSessionTranscript({ path: { "workspace_id": "workspace_id", "session_id": "session_id" } });getSessionTranscriptOutline
Get the full retained operator-message trail with reply previews
compozy.sessions.getSessionTranscriptOutline({ path, query }) → Promise<OutlineResult>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
GET /api/workspaces/{workspace_id}/sessions/{session_id}/transcript/outlineapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.getSessionTranscriptOutline({ path: { "workspace_id": "workspace_id", "session_id": "session_id" } });getSessionUsage
Get aggregated token usage for a session
compozy.sessions.getSessionUsage({ path, query }) → Promise<SessionUsageResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
GET /api/workspaces/{workspace_id}/sessions/{session_id}/usageapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.getSessionUsage({ path: { "workspace_id": "workspace_id", "session_id": "session_id" } });getSessionUsageTurns
Get per-turn session usage and native compaction markers
compozy.sessions.getSessionUsageTurns({ path, query }) → Promise<SessionUsageTurnsResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
GET /api/workspaces/{workspace_id}/sessions/{session_id}/usage/turnsapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.getSessionUsageTurns({ path: { "workspace_id": "workspace_id", "session_id": "session_id" } });getSubagent
Read one subagent
compozy.sessions.getSubagent({ path }) → Promise<SubagentPayload>
Options
- workspace_idstringpathrequired
- Workspace id
- subagent_idstringpathrequired
- Subagent id
GET /api/workspaces/{workspace_id}/subagents/{subagent_id}app tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.getSubagent({ path: { "workspace_id": "workspace_id", "subagent_id": "subagent_id" } });inspectSession
Inspect session health, wake audit, and policy correlation metadata
compozy.sessions.inspectSession({ path, query }) → Promise<SessionInspectResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- include_recent_wake_eventsbooleanquery
- Include recent wake audit rows
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
GET /api/workspaces/{workspace_id}/sessions/{session_id}/inspectapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.inspectSession({ path: { "workspace_id": "workspace_id", "session_id": "session_id" } });listGlobalSessionEvents
List persisted session events for a Global session
compozy.sessions.listGlobalSessionEvents({ path, query }) → Promise<SessionEventsResponse>
Options
- session_idstringpathrequired
- Session id
- sincestringquery
- Only events emitted since this timestamp
- limitintegerquery
- Maximum number of records to return; defaults to the newest 200 and is capped at 1000
- after_sequenceintegerquery
- Only return events after this sequence number
- typestringquery
- Event type
- agent_namestringquery
- Agent name
- turn_idstringquery
- Turn id
- archive"active" | "archived" | "all"query
- Select active, archived, or all events
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
GET /api/sessions/{session_id}/eventsapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.listGlobalSessionEvents({ path: { "session_id": "session_id" } });listProcesses
List processes grouped by session, including left-running processes
compozy.sessions.listProcesses({ query }) → Promise<ProcessesResponse>
Options
- workspace_idstringquery
- Workspace ID, or @user; mutually exclusive with all_workspaces
- all_workspacesbooleanquery
- Include all projects and User sessions
- orphanedbooleanquery
- Only processes of stopped, archived, deleted or unknown sessions
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
GET /api/processesapp tokens denied
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.listProcesses();listSessionClarifications
List the live pending clarification for a session
compozy.sessions.listSessionClarifications({ path, query }) → Promise<ClarificationsResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
GET /api/workspaces/{workspace_id}/sessions/{session_id}/clarificationsapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.listSessionClarifications({ path: { "workspace_id": "workspace_id", "session_id": "session_id" } });listSessionDescendants
List a session's child sessions, recursively
compozy.sessions.listSessionDescendants({ path, query }) → Promise<SessionsResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
GET /api/workspaces/{workspace_id}/sessions/{session_id}/descendantsapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.listSessionDescendants({ path: { "workspace_id": "workspace_id", "session_id": "session_id" } });listSessionEvents
List persisted session events
compozy.sessions.listSessionEvents({ path, query }) → Promise<SessionEventsResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- sincestringquery
- Only events emitted since this timestamp
- limitintegerquery
- Maximum number of records to return; defaults to the newest 200 and is capped at 1000
- after_sequenceintegerquery
- Only return events after this sequence number
- typestringquery
- Event type
- agent_namestringquery
- Agent name
- turn_idstringquery
- Turn id
- archive"active" | "archived" | "all"query
- Select active, archived, or all events
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
GET /api/workspaces/{workspace_id}/sessions/{session_id}/eventsapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.listSessionEvents({ path: { "workspace_id": "workspace_id", "session_id": "session_id" } });listSessionFacets
Count session catalog facets
compozy.sessions.listSessionFacets({ query }) → Promise<SessionCatalogFacetsResponse>
Options
- exclude_instance_mainbooleanquery
- Exclude instance main sessions from board counts
- exclude_finished_automationbooleanquery
- Exclude settled automation-run sessions; search, type, parent, root, archive=only and later=only reads ignore it
- exclude_automationbooleanquery
- Exclude every automation job or trigger run session the operator has not prompted from the counts, whatever its state; facets ignore the text query, so the counts keep excluding runs a search can list. type, parent, root, archive=only and later=only reads ignore it
- workspace_idstringquery
- Workspace id or path
- all_workspacesbooleanquery
- Use the explicit all-workspaces aggregate
- workspace_idsstring[]query
- Project IDs or @user; repeatable, requires all_workspaces
- worktreestringquery
- Filter by bound worktree id
- agentstringquery
- Filter by exact agent name
- subagents"include" | "exclude" | "only"query
- Subagent session visibility (default include)
- children"include" | "exclude"query
- Managed child visibility
- parentstringquery
- Filter by exact parent session id
- rootstringquery
- Filter by exact root session id (includes the root itself)
- resumablebooleanquery
- Only count sessions eligible for explicit attach
- state"starting" | "active" | "stopping" | "stopped"query
- Filter by exact session state
- type"user" | "system" | "coordinator" | "spawned"query
- Filter by exact session type
- archive"exclude" | "only" | "include"query
- Archived session visibility
- later"exclude" | "only" | "include"query
- Visibility of sessions parked in Later; excluded by default
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
GET /api/sessions/facetsapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.listSessionFacets();listSessionFolders
List session folders in manual order
compozy.sessions.listSessionFolders({ path, query }) → Promise<SessionFoldersResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- profilestringquery
- Act as this profile by name
GET /api/workspaces/{workspace_id}/session-foldersapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.listSessionFolders({ path: { "workspace_id": "workspace_id" } });listSessionInputs
List pending session input
compozy.sessions.listSessionInputs({ path, query }) → Promise<SessionInputListResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
GET /api/workspaces/{workspace_id}/sessions/{session_id}/prompt/queueapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.listSessionInputs({ path: { "workspace_id": "workspace_id", "session_id": "session_id" } });listSessionInteractions
List pending session interactions
compozy.sessions.listSessionInteractions({ path, query }) → Promise<SessionInteractionsResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- descendantsbooleanquery
- Include descendant sessions in the same workspace and profile
- status"pending" | "orphaned" | "resolved" | "timed_out" | "canceled"query
- Filter by interaction status
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
GET /api/workspaces/{workspace_id}/sessions/{session_id}/interactionsapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.listSessionInteractions({ path: { "workspace_id": "workspace_id", "session_id": "session_id" }, query: { "status": "pending" } });listSessionLinkedWork
List session linked work
compozy.sessions.listSessionLinkedWork({ path, query }) → Promise<SessionLinkedWorkResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
GET /api/workspaces/{workspace_id}/sessions/{session_id}/linksapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.listSessionLinkedWork({ path: { "workspace_id": "workspace_id", "session_id": "session_id" } });listSessionMonitors
List a session's monitors
compozy.sessions.listSessionMonitors({ path, query }) → Promise<SessionMonitorsResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
GET /api/workspaces/{workspace_id}/sessions/{session_id}/monitorsapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.listSessionMonitors({ path: { "workspace_id": "workspace_id", "session_id": "session_id" } });listSessionPendingInteractions
List pending session interactions
compozy.sessions.listSessionPendingInteractions({ path, query }) → Promise<SessionInteractionsResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- descendantsbooleanquery
- Include descendant sessions in the same workspace and profile
- status"pending" | "orphaned" | "resolved" | "timed_out" | "canceled"query
- Filter by interaction status
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
GET /api/workspaces/{workspace_id}/sessions/{session_id}/pending-interactionsapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.listSessionPendingInteractions({ path: { "workspace_id": "workspace_id", "session_id": "session_id" }, query: { "status": "pending" } });listSessionProcesses
List attributed session processes
compozy.sessions.listSessionProcesses({ path, query }) → Promise<SessionProcessesResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
GET /api/workspaces/{workspace_id}/sessions/{session_id}/processesapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.listSessionProcesses({ path: { "workspace_id": "workspace_id", "session_id": "session_id" } });listSessionSubagents
List a session's subagents
compozy.sessions.listSessionSubagents({ path, query }) → Promise<SubagentListPayload>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Parent session id
- origin"delegated" | "provider_native"query
- Subagent origin
- statusstringquery
- Comma-separated subagent statuses
- limitintegerquery
- Subagents per page (default 50, maximum 200)
- cursorstringquery
- Opaque next_cursor from the previous page
- order"newest" | "urgency"query
- Row order: newest first (default), or most urgent first (waiting, failed, working, queued, settled) then newest
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
GET /api/workspaces/{workspace_id}/sessions/{session_id}/subagentsapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.listSessionSubagents({ path: { "workspace_id": "workspace_id", "session_id": "session_id" }, query: { "status": "status" } });listSessionTools
List session-callable registry tools
compozy.sessions.listSessionTools({ path, query }) → Promise<ToolsResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- agent_namestringquery
- Effective agent name
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
GET /api/workspaces/{workspace_id}/sessions/{session_id}/toolsapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.listSessionTools({ path: { "workspace_id": "workspace_id", "session_id": "session_id" } });listSessions
List sessions
compozy.sessions.listSessions({ query }) → Promise<SessionCatalogResponse>
Options
- workspace_idstringquery
- Workspace id or path
- all_workspacesbooleanquery
- Use the explicit all-workspaces aggregate
- workspace_idsstring[]query
- Project IDs or @user; repeatable, requires all_workspaces
- include_healthbooleanquery
- Include metadata-only health for returned sessions
- skip_totalbooleanquery
- Omit the exact catalog count for a bounded cursor read
- exclude_instance_mainbooleanquery
- Exclude always-on main sessions from the page and its total
- exclude_finished_automationbooleanquery
- Exclude settled automation-run sessions; search, type, parent, root, archive=only and later=only reads ignore it
- exclude_automationbooleanquery
- Exclude every automation job or trigger run session the operator has not prompted, whatever its state; search, type, parent, root, archive=only and later=only reads ignore it
- state"starting" | "active" | "stopping" | "stopped"query
- Filter by exact session state
- type"user" | "system" | "coordinator" | "spawned"query
- Filter by exact session type
- agentstringquery
- Filter by exact agent definition name
- subagents"include" | "exclude" | "only"query
- Subagent session visibility (default include)
- children"include" | "exclude"query
- Managed child visibility
- parentstringquery
- Filter by exact parent session id
- rootstringquery
- Filter by exact root session id (includes the root itself)
- worktreestringquery
- Filter by exact bound worktree id
- qstringquery
- Search session id, name, agent, or provider; title_agent searches visible title and agent
- search_fields"title_agent"query
- Select visible title/agent search instead of the default catalog fields
- resumablebooleanquery
- Only list sessions eligible for explicit attach
- attentionbooleanquery
- Only list sessions in the needs-you attention class
- board_columnstring[]query
- Repeatable board column filter: needs_you, working, waiting, in_review, done
- badgestringquery
- Filter by comma-separated exact session badges
- archive"exclude" | "only" | "include"query
- Archived session visibility
- later"exclude" | "only" | "include"query
- Visibility of sessions parked in Later; excluded by default
- sort"recent" | "created" | "name" | "last_activity" | "attention" | "navigator" | "manual"query
- Stable session ordering
- cursorstringquery
- Opaque next_cursor from the previous page
- limitintegerquery
- Sessions per page (1-100)
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
GET /api/sessionsapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.listSessions();listWorkspaceSessions
List sessions
compozy.sessions.listWorkspaceSessions({ path, query }) → Promise<SessionCatalogResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- workspace_idsstring[]query
- Project IDs or @user; repeatable, requires all_workspaces
- include_healthbooleanquery
- Include metadata-only health for returned sessions
- skip_totalbooleanquery
- Omit the exact catalog count for a bounded cursor read
- exclude_instance_mainbooleanquery
- Exclude always-on main sessions from the page and its total
- exclude_finished_automationbooleanquery
- Exclude settled automation-run sessions; search, type, parent, root, archive=only and later=only reads ignore it
- exclude_automationbooleanquery
- Exclude every automation job or trigger run session the operator has not prompted, whatever its state; search, type, parent, root, archive=only and later=only reads ignore it
- state"starting" | "active" | "stopping" | "stopped"query
- Filter by exact session state
- type"user" | "system" | "coordinator" | "spawned"query
- Filter by exact session type
- agentstringquery
- Filter by exact agent definition name
- subagents"include" | "exclude" | "only"query
- Subagent session visibility (default include)
- children"include" | "exclude"query
- Managed child visibility
- parentstringquery
- Filter by exact parent session id
- rootstringquery
- Filter by exact root session id (includes the root itself)
- worktreestringquery
- Filter by exact bound worktree id
- qstringquery
- Search session id, name, agent, or provider; title_agent searches visible title and agent
- search_fields"title_agent"query
- Select visible title/agent search instead of the default catalog fields
- resumablebooleanquery
- Only list sessions eligible for explicit attach
- attentionbooleanquery
- Only list sessions in the needs-you attention class
- board_columnstring[]query
- Repeatable board column filter: needs_you, working, waiting, in_review, done
- badgestringquery
- Filter by comma-separated exact session badges
- archive"exclude" | "only" | "include"query
- Archived session visibility
- later"exclude" | "only" | "include"query
- Visibility of sessions parked in Later; excluded by default
- sort"recent" | "created" | "name" | "last_activity" | "attention" | "navigator" | "manual"query
- Stable session ordering
- cursorstringquery
- Opaque next_cursor from the previous page
- limitintegerquery
- Sessions per page (1-100)
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
GET /api/workspaces/{workspace_id}/sessionsapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.listWorkspaceSessions({ path: { "workspace_id": "workspace_id" } });markSessionSeen
Mark a session's Needs you as seen until its next occurrence; a session waiting on an answer, a sign-in, or a stop is refused
compozy.sessions.markSessionSeen({ path, query }) → Promise<SessionResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Act as this profile by name
POST /api/workspaces/{workspace_id}/sessions/{session_id}/mark-seenapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.markSessionSeen({ path: { "workspace_id": "workspace_id", "session_id": "session_id" } });moveSession
Move a session into a folder or back to the workspace root
compozy.sessions.moveSession({ path, query, body }) → Promise<SessionFoldersResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Act as this profile by name
Request bodyMoveSessionRequest
POST /api/workspaces/{workspace_id}/sessions/{session_id}/moveapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.moveSession({ path: { "workspace_id": "workspace_id", "session_id": "session_id" }, body: { /* request fields */ } });moveSessionToLater
Stop a session and its children and park them in Later, with an optional reason and return time
compozy.sessions.moveSessionToLater({ path, query, body }) → Promise<SessionResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Act as this profile by name
Request bodyMoveSessionToLaterRequest
POST /api/workspaces/{workspace_id}/sessions/{session_id}/laterapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.moveSessionToLater({ path: { "workspace_id": "workspace_id", "session_id": "session_id" }, body: { /* request fields */ } });moveSessionToProfile
Copy a stopped user session into another profile and archive the original
compozy.sessions.moveSessionToProfile({ path, query, body }) → Promise<MoveSessionToProfileResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Act as this profile by name
Request bodyMoveSessionToProfileRequest
POST /api/workspaces/{workspace_id}/sessions/{session_id}/move-to-profileapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.moveSessionToProfile({ path: { "workspace_id": "workspace_id", "session_id": "session_id" }, body: { /* request fields */ } });previewSessionDerive
Preview what a continue or fork of a session would carry
compozy.sessions.previewSessionDerive({ path, query }) → Promise<SessionDerivePreviewResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Source session id
- message_idstringquery
- Durable user message to cut through (fork from here)
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
GET /api/workspaces/{workspace_id}/sessions/{session_id}/derive/previewapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.previewSessionDerive({ path: { "workspace_id": "workspace_id", "session_id": "session_id" } });promoteSessionInput
Promote queued session input to steering
compozy.sessions.promoteSessionInput({ path, query, body }) → Promise<SendPromptResultResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- queue_entry_idstringpathrequired
- Queue entry id
- profilestringquery
- Act as this profile by name
Request bodyPromoteSessionInputRequest
POST /api/workspaces/{workspace_id}/sessions/{session_id}/prompt/queue/{queue_entry_id}/steerapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.promoteSessionInput({ path: { "workspace_id": "workspace_id", "session_id": "session_id", "queue_entry_id": "queue_entry_id" }, body: { /* request fields */ } });readSessionAttachmentBytes
Read session attachment bytes
compozy.sessions.readSessionAttachmentBytes({ path, query }) → Promise<Blob | File>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- attachment_idstringpathrequired
- Attachment id
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
GET /api/workspaces/{workspace_id}/sessions/{session_id}/attachments/{attachment_id}/bytesapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.readSessionAttachmentBytes({ path: { "workspace_id": "workspace_id", "session_id": "session_id", "attachment_id": "attachment_id" } });refreshSessionPullRequest
Refresh a session pull request
compozy.sessions.refreshSessionPullRequest({ path, query }) → Promise<SessionPullRequestResponse>
Options
- session_idstringpathrequired
- Session id
- profilestringquery
- Act as this profile by name
POST /api/sessions/{session_id}/pull-request/refreshapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.refreshSessionPullRequest({ path: { "session_id": "session_id" } });refreshSessionSoul
Refresh an idle session's Soul snapshot through body-level CAS
compozy.sessions.refreshSessionSoul({ path, query, body }) → Promise<AgentSoulPayload>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Act as this profile by name
Request bodySessionSoulRefreshRequest
POST /api/workspaces/{workspace_id}/sessions/{session_id}/soul/refreshapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.refreshSessionSoul({ path: { "workspace_id": "workspace_id", "session_id": "session_id" }, body: { /* request fields */ } });refreshSessionWorkLink
Ask the forge again about one linked item
compozy.sessions.refreshSessionWorkLink({ path, query, body }) → Promise<SessionLinkedWorkResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Act as this profile by name
Request bodySessionWorkLinkRequest
POST /api/workspaces/{workspace_id}/sessions/{session_id}/links/refreshapp tokens denied
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.refreshSessionWorkLink({ path: { "workspace_id": "workspace_id", "session_id": "session_id" }, body: { /* request fields */ } });removeSessionWorkLink
Unlink session work
compozy.sessions.removeSessionWorkLink({ path, query, body }) → Promise<SessionLinkedWorkResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Act as this profile by name
Request bodySessionWorkLinkRequest
DELETE /api/workspaces/{workspace_id}/sessions/{session_id}/linksapp tokens denied
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.removeSessionWorkLink({ path: { "workspace_id": "workspace_id", "session_id": "session_id" }, body: { /* request fields */ } });renameSession
Rename one user session
compozy.sessions.renameSession({ path, query, body }) → Promise<SessionResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Act as this profile by name
Request bodyRenameSessionRequest
PATCH /api/workspaces/{workspace_id}/sessions/{session_id}app tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.renameSession({ path: { "workspace_id": "workspace_id", "session_id": "session_id" }, body: { /* request fields */ } });renameSessionFolder
Rename a session folder
compozy.sessions.renameSessionFolder({ path, query, body }) → Promise<SessionFolderResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- folder_idstringpathrequired
- Session folder id
- profilestringquery
- Act as this profile by name
Request bodyRenameSessionFolderRequest
PATCH /api/workspaces/{workspace_id}/session-folders/{folder_id}app tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.renameSessionFolder({ path: { "workspace_id": "workspace_id", "folder_id": "folder_id" }, body: { /* request fields */ } });reorderSessionFolders
Set the complete session folder order
compozy.sessions.reorderSessionFolders({ path, query, body }) → Promise<SessionFoldersResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- profilestringquery
- Act as this profile by name
Request bodyReorderSessionFoldersRequest
PUT /api/workspaces/{workspace_id}/session-order/foldersapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.reorderSessionFolders({ path: { "workspace_id": "workspace_id" }, body: { /* request fields */ } });reorderSessions
Set the manual session order in a folder or the workspace root
compozy.sessions.reorderSessions({ path, query, body }) → Promise<SessionFoldersResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- profilestringquery
- Act as this profile by name
Request bodyReorderSessionsRequest
PUT /api/workspaces/{workspace_id}/session-order/sessionsapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.reorderSessions({ path: { "workspace_id": "workspace_id" }, body: { /* request fields */ } });repairSession
Inspect and repair an interrupted session transcript
compozy.sessions.repairSession({ path, query }) → Promise<SessionRepairResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- dry_runbooleanquery
- Report planned repairs without persisting new events
- forcebooleanquery
- Allow repair for stopped sessions whose stop reason is not crash or error
- profilestringquery
- Act as this profile by name
POST /api/workspaces/{workspace_id}/sessions/{session_id}/repairapp tokens denied
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.repairSession({ path: { "workspace_id": "workspace_id", "session_id": "session_id" } });replaceSessionInput
Replace queued session input atomically
compozy.sessions.replaceSessionInput({ path, query, body }) → Promise<SessionInputResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- queue_entry_idstringpathrequired
- Queue entry id
- profilestringquery
- Act as this profile by name
Request bodyReplaceSessionInputRequest
PUT /api/workspaces/{workspace_id}/sessions/{session_id}/prompt/queue/{queue_entry_id}app tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.replaceSessionInput({ path: { "workspace_id": "workspace_id", "session_id": "session_id", "queue_entry_id": "queue_entry_id" }, body: { /* request fields */ } });resumeSessionFromLater
Return a parked session, and optionally its parked children, to the normal flow
compozy.sessions.resumeSessionFromLater({ path, query, body }) → Promise<SessionResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Act as this profile by name
Request bodyResumeSessionFromLaterRequest
POST /api/workspaces/{workspace_id}/sessions/{session_id}/resume-laterapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.resumeSessionFromLater({ path: { "workspace_id": "workspace_id", "session_id": "session_id" }, body: { /* request fields */ } });rewindSessionConversation
Rewind a conversation before one durable user message
compozy.sessions.rewindSessionConversation({ path, query, body }) → Promise<SessionConversationRewindResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Act as this profile by name
Request bodySessionConversationRewindRequest
POST /api/workspaces/{workspace_id}/sessions/{session_id}/rewindapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.rewindSessionConversation({ path: { "workspace_id": "workspace_id", "session_id": "session_id" }, body: { /* request fields */ } });searchGlobalSessionTranscript
Search retained transcript messages with bounded literal matches for a Global session
compozy.sessions.searchGlobalSessionTranscript({ path, query }) → Promise<SearchResult>
Options
- session_idstringpathrequired
- Session id
- qstringqueryrequired
- Literal case-insensitive text; 1 to 4096 bytes
- limitintegerquery
- Maximum matches; defaults to 200, capped at 1000; truncated reports omitted matches
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
GET /api/sessions/{session_id}/transcript/searchapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.searchGlobalSessionTranscript({ path: { "session_id": "session_id" }, query: { "q": "q" } });searchSessionFiles
Search files and folders under a session's working directory
compozy.sessions.searchSessionFiles({ path, query }) → Promise<SessionFilesResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- qstringquery
- Search text; empty returns the shallowest entries
- limitintegerquery
- Maximum entries returned
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
GET /api/workspaces/{workspace_id}/sessions/{session_id}/filesapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.searchSessionFiles({ path: { "workspace_id": "workspace_id", "session_id": "session_id" } });searchSessionTools
Search session-callable registry tools
compozy.sessions.searchSessionTools({ path, query, body }) → Promise<ToolsResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Act as this profile by name
Request bodyToolSearchRequest
POST /api/workspaces/{workspace_id}/sessions/{session_id}/tools/searchapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.searchSessionTools({ path: { "workspace_id": "workspace_id", "session_id": "session_id" }, body: { /* request fields */ } });searchSessionTranscript
Search retained transcript messages with bounded literal matches
compozy.sessions.searchSessionTranscript({ path, query }) → Promise<SearchResult>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- qstringqueryrequired
- Literal case-insensitive text; 1 to 4096 bytes
- limitintegerquery
- Maximum matches; defaults to 200, capped at 1000; truncated reports omitted matches
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
GET /api/workspaces/{workspace_id}/sessions/{session_id}/transcript/searchapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.searchSessionTranscript({ path: { "workspace_id": "workspace_id", "session_id": "session_id" }, query: { "q": "q" } });searchSessionWorkCandidates
Search this project for link candidates
compozy.sessions.searchSessionWorkCandidates({ path, query }) → Promise<WorkCandidates>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
- kind"branches" | "pull_requests"query
- Candidate source; defaults to pull requests with local branch fallback
- qstringquery
- Search repository pull requests or local branches
- pagestringquery
- Page number, starting at 1
- limitstringquery
- Page size, at most 100; page 1 may include one additional exact PR match, which is omitted from later pages
GET /api/workspaces/{workspace_id}/sessions/{session_id}/link-candidatesapp tokens denied
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.searchSessionWorkCandidates({ path: { "workspace_id": "workspace_id", "session_id": "session_id" } });prompt
Send, queue, interrupt, or steer a session prompt
compozy.prompt(input) → Promise<PromptReply>
Options
- workspaceIdstringpathrequired
- Workspace id
- sessionIdstringpathrequired
- Session id
POST /api/workspaces/{workspace_id}/sessions/{session_id}/promptapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const reply = await compozy.prompt({ workspaceId: "workspace-id", sessionId: "session-id", message: "Hello",});if (reply.kind === "stream") { for await (const chunk of reply.chunks) console.log(chunk);}setSessionParent
Adopt a parentless user session as a child of another session
compozy.sessions.setSessionParent({ path, query, body }) → Promise<SessionResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Act as this profile by name
Request bodySetSessionParentRequest
PUT /api/workspaces/{workspace_id}/sessions/{session_id}/parentapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.setSessionParent({ path: { "workspace_id": "workspace_id", "session_id": "session_id" }, body: { /* request fields */ } });setSessionRuntime
Select the default runtime for future prompts
compozy.sessions.setSessionRuntime({ path, query, body }) → Promise<SessionResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Act as this profile by name
Request bodySetSessionRuntimeRequest
PUT /api/workspaces/{workspace_id}/sessions/{session_id}/runtimeapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.setSessionRuntime({ path: { "workspace_id": "workspace_id", "session_id": "session_id" }, body: { /* request fields */ } });steerSessionPrompt
Stage steering input for the active session turn
compozy.sessions.steerSessionPrompt({ path, query, body }) → Promise<SendPromptResultResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Act as this profile by name
Request bodySteerPromptRequest
POST /api/workspaces/{workspace_id}/sessions/{session_id}/steerapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.steerSessionPrompt({ path: { "workspace_id": "workspace_id", "session_id": "session_id" }, body: { /* request fields */ } });stopSession
Stop a session without deleting persisted history
compozy.sessions.stopSession({ path, query, body }) → Promise<StopSessionResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Act as this profile by name
Request bodyStopSessionRequest
POST /api/workspaces/{workspace_id}/sessions/{session_id}/stopapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.stopSession({ path: { "workspace_id": "workspace_id", "session_id": "session_id" }, body: { /* request fields */ } });streamGlobalSession
Stream raw session events or fenced transcript changes for a Global session
compozy.events("streamGlobalSession", { path, query }) → AsyncIterable<StreamEvent<SseFrame<"streamGlobalSession">>>
Options
- session_idstringpathrequired
- Session id
- after_sequenceintegerquery
- Initial cursor when Last-Event-ID is not supplied
- frames"raw" | "transcript"query
- Frame mode; transcript is the default and raw preserves persisted event frames
- epochintegerquery
- Expected transcript epoch for a fenced reconnect
- generationintegerquery
- Expected materialized projection generation for a fenced reconnect
- limitintegerquery
- Maximum entries per transcript snapshot or change batch
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
GET /api/sessions/{session_id}/streamapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();for await (const frame of compozy.events("streamGlobalSession", { path: { "session_id": "session_id" } })) { console.log(frame);}streamSession
Stream raw session events or fenced transcript changes
compozy.events("streamSession", { path, query }) → AsyncIterable<StreamEvent<SseFrame<"streamSession">>>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- after_sequenceintegerquery
- Initial cursor when Last-Event-ID is not supplied
- frames"raw" | "transcript"query
- Frame mode; transcript is the default and raw preserves persisted event frames
- epochintegerquery
- Expected transcript epoch for a fenced reconnect
- generationintegerquery
- Expected materialized projection generation for a fenced reconnect
- limitintegerquery
- Maximum entries per transcript snapshot or change batch
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
GET /api/workspaces/{workspace_id}/sessions/{session_id}/streamapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();for await (const frame of compozy.events("streamSession", { path: { "workspace_id": "workspace_id", "session_id": "session_id" } })) { console.log(frame);}streamSessionCatalog
Stream session catalog changes across workspaces
compozy.events("streamSessionCatalog", { query }) → AsyncIterable<StreamEvent<SseFrame<"streamSessionCatalog">>>
Options
- workspace_idstringquery
- Workspace id or path
- all_workspacesbooleanquery
- Subscribe to the explicit all-workspaces aggregate
- last_event_idstringquery
- Resume cursor when Last-Event-ID cannot be set; the header takes precedence
- profilestringquery
- Read one profile's rows by name
- all_profilesbooleanquery
- Read the owner-labeled all-profiles aggregate
GET /api/sessions/catalog-streamapp tokens denied
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();for await (const frame of compozy.events("streamSessionCatalog", {})) { console.log(frame);}terminateProcesses
Terminate identity-verified processes with missing or retained session owners
compozy.sessions.terminateProcesses({ query, body }) → Promise<TerminateSessionProcessesResponse>
Options
- profilestringquery
- Act as this profile by name
Request bodyTerminateProcessesRequest
POST /api/processes/terminateapp tokens denied
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.terminateProcesses({ body: { /* request fields */ } });terminateSessionProcesses
Terminate identity-verified session processes
compozy.sessions.terminateSessionProcesses({ path, query, body }) → Promise<TerminateSessionProcessesResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Act as this profile by name
Request bodyTerminateSessionProcessesRequest
POST /api/workspaces/{workspace_id}/sessions/{session_id}/processes/terminateapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.terminateSessionProcesses({ path: { "workspace_id": "workspace_id", "session_id": "session_id" }, body: { /* request fields */ } });unarchiveSession
Restore an archived session
compozy.sessions.unarchiveSession({ path, query }) → Promise<SessionResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Act as this profile by name
POST /api/workspaces/{workspace_id}/sessions/{session_id}/unarchiveapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.unarchiveSession({ path: { "workspace_id": "workspace_id", "session_id": "session_id" } });unbindSessionWorktree
Return an idle session to the workspace root in place
compozy.sessions.unbindSessionWorktree({ path, query }) → Promise<SessionResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Act as this profile by name
- expected_worktree_idstringquery
- Expected current worktree id; empty for workspace root
DELETE /api/workspaces/{workspace_id}/sessions/{session_id}/worktreeapp tokens denied
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.unbindSessionWorktree({ path: { "workspace_id": "workspace_id", "session_id": "session_id" } });updateSessionPresence
Update operator session presence
compozy.sessions.updateSessionPresence({ path, query, body }) → Promise<UpdateSessionPresenceResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Act as this profile by name
Request bodySessionPresenceRequest
POST /api/workspaces/{workspace_id}/sessions/{session_id}/presenceapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.updateSessionPresence({ path: { "workspace_id": "workspace_id", "session_id": "session_id" }, body: { /* request fields */ } });uploadSessionAttachment
Upload a session attachment
compozy.sessions.uploadSessionAttachment({ path, query, body }) → Promise<SessionAttachmentUploadResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Act as this profile by name
Request bodyUploadSessionAttachmentData["body"]
POST /api/workspaces/{workspace_id}/sessions/{session_id}/attachmentsapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.uploadSessionAttachment({ path: { "workspace_id": "workspace_id", "session_id": "session_id" }, body: { file: new Blob(["content"]) } });waitForSession
Wait for a session state
compozy.sessions.waitForSession({ path, query, body }) → Promise<SessionWaitResponse>
Options
- workspace_idstringpathrequired
- Workspace id
- session_idstringpathrequired
- Session id
- profilestringquery
- Act as this profile by name
Request bodySessionWaitRequest
POST /api/workspaces/{workspace_id}/sessions/{session_id}/waitapp tokens allowed
import { Compozy } from "@compozy/client"; const compozy = await Compozy.connect();const result = await compozy.sessions.waitForSession({ path: { "workspace_id": "workspace_id", "session_id": "session_id" }, body: { /* request fields */ } });