CloudSession

class CloudSession extends AcpSession

CloudSession(id: string, connection: JsonRpcConnection): CloudSession

acceptPlan(params: SessionScopedParams<typeof void>): Promise<PlanAcceptResponse>

beginReplay(): void

cancel(): void

configOption(id: string): undefined | SessionConfigOption

decideRepoIndex(sourceEventId: string, decision: RepoIndexDecision): Promise<RepoIndexDecideResponse>

editPlan(params: SessionScopedParams<typeof void>): Promise<PlanEditResponse>

enableTurnStateUpdates(): void

endReplay(): SessionUpdate[]

enrichPermissionRequest(request: PermissionRequest): PermissionRequest

events(options?: ObserveOptions): AsyncGenerator<SessionEvent>

const session = await devin.attach("devin-…");
for await (const event of session.events()) {
  if (event.type === "status") console.log(event.status, event.userActionRequired);
}

extNotify(method: M, params: SessionScopedParams<M>): void

extNotify(method: string, params?: unknown): void

extRequest(method: M, params: SessionScopedParams<M>): Promise<CognitionRequestResult<M>>

extRequest(method: string, params?: unknown): Promise<T>

getNetPolicy(): Promise<NetPolicyGetResponse>

handleConnectionClosed(error: ConnectionClosedError): void

handleExtension(method: string, params: unknown): void

handleReleased(): void

handleResult(result: unknown): void

handleUpdate(__namedParameters: Pick<SessionNotification, "update" | "_meta">): void

heartbeat(): Promise<void>

instrument(observer: SessionObserver): void

listSecrets(): Promise<SecretListResponse>

loadPage(startIndex: number, limit?: number): Promise<HistoryPage>

markRead(isUnread?: boolean): Promise<void>

postMessage(input: PromptInput, options?: PromptOptions): Promise<PromptResult>

provideSecret(params: SessionScopedParams<typeof void>): Promise<SecretProvideResponse>

reboot(): Promise<void>

rename(title: string): Promise<void>

respondToPermission(params: SessionScopedParams<typeof void>): Promise<PermissionRespondResponse>

run(input: PromptInput, options: RunOptions<T> & { output: StandardSchema<T> }): Turn<T>

const outcome = await session.run("Summarize the repo", {
  output: z.object({ summary: z.string() }),
});
outcome.output.summary;

run(input: PromptInput, options?: Omit<RunOptions<unknown>, "output"> & { output: undefined }): Turn

const outcome = await session.run("Summarize the repo", {
  output: z.object({ summary: z.string() }),
});
outcome.output.summary;

run(input: PromptInput, options: RunOptions<T>): Turn<undefined | T>

const outcome = await session.run("Summarize the repo", {
  output: z.object({ summary: z.string() }),
});
outcome.output.summary;

saveSecret(params: SessionScopedParams<typeof void>): Promise<SecretSaveResponse>

send(input: PromptInput, options?: PromptOptions): Promise<PromptResult>

sendFeedback(params: SessionScopedParams<typeof void>): Promise<SessionFeedbackResponse>

setMode(modeId: string): Promise<void>

setOrg(orgId: string, repos?: string[]): Promise<void>

setRepos(repos: string[]): Promise<void>

setSpendingLimit(maxCredits: number, options?: SpendingLimitOptions): Promise<SessionSpendingLimitSetResponse>

stream(input: PromptInput, options?: PromptOptions): AsyncGenerator<SessionEvent, PromptResult, undefined>

streamUpdates(input: PromptInput, options?: PromptOptions): AsyncGenerator<SessionUpdate, PromptResult, undefined>

togglePlanConfirmMode(planEventId: string): Promise<PlanToggleConfirmModeResponse>

updateNetPolicy(params: SessionScopedParams<typeof void>): Promise<NetPolicyUpdateResponse>

updateQueue(op: SessionScopedParams<"_cognition.ai/queuedMessages/update">): Promise<QueuedMessagesUpdateResponse>

updates(__namedParameters?: ObserveOptions): AsyncGenerator<SessionUpdate>