LocalSession

class LocalSession extends AcpSession

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

backgroundSubagent(agentId: string): Promise<void>

beginReplay(): void

cancel(): void

cancelSubagent(agentId: string): Promise<void>

configOption(id: string): undefined | SessionConfigOption

enableTurnStateUpdates(): void

end(reason: string, options?: EndSessionOptions): Promise<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);
}

export(format?: "forest"): Promise<SessionExportResponse>

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>

foregroundSubagent(agentId: string): Promise<void>

forkFromStep(targetNodeId: number): Promise<RevertForkFromStepResponse>

handleConnectionClosed(error: ConnectionClosedError): void

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

handleReleased(): void

handleResult(result: unknown): void

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

instrument(observer: SessionObserver): void

listRevertSteps(): Promise<RevertListStepsResponse>

models(): undefined | SessionModels

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

previewRevert(targetNodeId: number): Promise<RevertPreviewResponse>

rename(title: string): Promise<void>

resumeRevert(questionNodeId: number): Promise<RevertResumeResponse>

revert(targetNodeId: number, options?: RevertOptions): Promise<RevertExecuteResponse>

reviseCommand(command: string, note: string): Promise<CommandReviseResponse>

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;

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

setMode(modeId: string): Promise<void>

setModel(model: string | FusionModel): Promise<void>

share(): Promise<SessionShareResponse>

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

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

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