ASM (ASM v0.13.0)

@type session_info() :: %{
  session_id: String.t(),
  provider: ASM.Provider.provider_name(),
  options: keyword(),
  status: atom(),
  execution_context_ref: String.t(),
  connector_instance_ref: String.t(),
  runtime_auth: map()
}

session_ref()

@type session_ref() :: GenServer.server()

Functions

approve(session, approval_id, decision)

@spec approve(session_ref(), String.t(), :allow | :deny) ::
  :ok | {:error, ASM.Error.t()}

checkpoint(session)

@spec checkpoint(session_ref()) :: {:ok, map() | nil} | {:error, ASM.Error.t()}

cleanup_managed_session(session_id, reason \\ :scope_closed)

@spec cleanup_managed_session(String.t(), atom()) ::
  :ok | {:error, ASM.Error.t() | :not_found}

Closes a governed managed session materialization by opaque session id.

cost(session)

@spec cost(session_ref()) :: map()

health(session)

@spec health(session_ref()) :: :healthy | :degraded | {:unhealthy, term()}

interrupt(session, run_id)

@spec interrupt(session_ref(), String.t()) :: :ok | {:error, ASM.Error.t()}

intervene(session, run_id, prompt, opts \\ [])

@spec intervene(session_ref(), String.t(), String.t(), keyword()) ::
  {:ok, String.t(), pid() | :queued} | {:error, ASM.Error.t()}

list_provider_sessions(provider_or_session, opts \\ [])

@spec list_provider_sessions(
  session_ref() | atom(),
  keyword()
) :: {:ok, [ASM.SessionControl.Entry.t()]} | {:error, ASM.Error.t()}

pause(session, run_id)

@spec pause(session_ref(), String.t()) :: :ok | {:error, ASM.Error.t()}

query(session_or_provider, prompt, opts \\ [])

@spec query(session_ref() | atom(), String.t(), keyword()) ::
  {:ok, ASM.Result.t()} | {:error, ASM.Error.t()}

resume_run(session, prompt, opts \\ [])

@spec resume_run(session_ref(), String.t(), keyword()) ::
  {:ok, String.t(), pid() | :queued} | {:error, ASM.Error.t()}

revoke_managed_session(session_id, revocation)

@spec revoke_managed_session(String.t(), map() | keyword()) ::
  :ok | {:error, ASM.Error.t() | :not_found}

Revokes a governed managed session by opaque session id.

send_input(session, run_id, input)

@spec send_input(session_ref(), String.t(), iodata()) :: :ok | {:error, ASM.Error.t()}

Hands more input to a run that is still going, without ending its turn.

The resolved lane must explicitly declare :incremental_input. An open stdin descriptor is not enough: a CLI may leave it open without reading it after startup. Unsupported lanes fail closed; use intervene/4 to interrupt and resume the same provider thread.

session_id(session)

@spec session_id(session_ref()) :: String.t() | nil

session_info(session)

@spec session_info(session_ref()) :: {:ok, session_info()} | {:error, ASM.Error.t()}

start_link(opts \\ [])

@spec start_link(keyword()) :: {:ok, session_ref()} | {:error, ASM.Error.t() | term()}

start_session(opts \\ [])

@spec start_session(keyword()) ::
  {:ok, session_ref()} | {:error, ASM.Error.t() | term()}

stop_session(session_ref)

@spec stop_session(String.t() | pid()) :: :ok | {:error, :not_found}

stream(session, prompt, opts \\ [])

@spec stream(session_ref(), String.t(), keyword()) :: Enumerable.t()