harnest.context

All Python modules · Import and compatibility guidance Use from harnest import context for capabilities bound to the current managed invocation. Access to a capability does not extend its lifetime beyond that invocation.

Invocation capabilities

These attributes are resolved at runtime rather than stored as module globals. Use the linked types for their methods; accessing a managed property during import or outside its required runtime raises an availability error.

Attribute	API
`context.current()`	`AgentContext`: invocation identity and named resources.
`context.agent`	`LocalAgentRuntime`: start or access a root agent session from task execution.
`context.session`	`SessionContext`: current session data.
`context.memory`	`MemoryContext`: user-scoped long-term memory.
`context.assets`	`ScopedAssets`: user/session-scoped assets.
`context.sandboxes["name"]`	Named sandbox execution: execute only through an assigned sandbox.
`context.extensions("name")`	`ExtensionContext`: installed extension capability; see its typed extension reference.
`context.storage`	`StorageContext`: named custom storage.
`context.credentials`	`CredentialContext`: credential resolution.
`context.mcp`	`MCPContext`: governed MCP calls.
`context.skills`	`SkillAccess`: current agent’s skills.
`context.decisions`	`DecisionContext`: registered typed decisions.

Identity properties such as context.user_id, context.session_id, and context.invocation_id read from the active AgentContext. See Agent runtime principals for authorization and Tasks for task-initiated agent calls.

Memory operations

Operation	Behavior
`put(key, content, ...)`	Explicitly insert or replace one scoped record
`get(key)`	Return a live record or `None`
`list(limit=20, after=None)`	Return a bounded page in ascending key order
`search(query, limit=20, after=None)`	Return literal, case-sensitive content matches
`delete(key, ...)`	Remove the record and its index references; return whether it existed

Session operations

Operation	Behavior
`get(key, default=None)`	Returns a detached value
`set(key, value)`	Replaces one value
`update(values)`	Writes several keys under one session lease
`delete(key)`	Deletes one key and returns whether it existed
`namespace(name)`	Isolates domain or plugin keys

Exports

Name	Kind
`AgentContext`	Class
`AgentContinuationUnsupportedError`	Class
`AgentInvocationTimeout`	Class
`AgentInvocationUnavailableError`	Class
`AgentPendingResponse`	Class
`AgentResponse`	Class
`AgentSession`	Class
`AgentSessionNotFoundError`	Class
`AgentStreamItem`	Class
`ContextRegistration`	Class
`ContextResourceError`	Class
`ContextUnavailableError`	Class
`LocalAgentRuntime`	Class
`MemoryContext`	Class
`ScopedAssets`	Class
`SessionContext`	Class
`SessionDataError`	Class
`StorageContext`	Class
`activate_agent_scope`	Function
`current`	Function
`derive_agent_context`	Function
`provider`	Function
`resource`	Function

AgentContext

Stable invocation identity and its explicitly exported resources. Obtain this object from the owning Harnest API; its constructor includes runtime bindings. Fields (— means no declared default):

Field	Type	Default
`framework`	`str`	`—`
`agent_name`	`str`	`—`
`invocation_id`	`str`	`—`
`user_id`	`str`	`—`
`session_id`	`str`	`—`
`metadata`	`Mapping[str, Any]`	`—`
`parent_agent_name`	`str \| None`	`—`
`depth`	`int`	`—`

Example

from harnest.context import AgentContext

context: AgentContext  # returned by Harnest, not constructed directly

AgentContext.resource

AgentContext.resource(name: str, expected_type: type[Any] | None = None) -> Any

Return one named capability without exposing the whole registry.

Parameters and example

Parameter	Type	Default
`name`	`str`	Required
`expected_type`	`type[Any] \| None`	`None`

from harnest.context import AgentContext

context: AgentContext
result = context.resource(name=...)

AgentContext.is_root

Report whether this scope represents the compiled root agent.

Example

from harnest.context import AgentContext

context: AgentContext
value = context.is_root

AgentContinuationUnsupportedError

A local invocation reached a continuation its caller cannot service.

AgentContinuationUnsupportedError(kind: str) -> None

Example

from harnest.context import AgentContinuationUnsupportedError

try:
    ...
except AgentContinuationUnsupportedError as error:
    ...

AgentInvocationTimeout

An in-process agent invocation exceeded its configured deadline.

Example

from harnest.context import AgentInvocationTimeout

try:
    ...
except AgentInvocationTimeout as error:
    ...

AgentInvocationUnavailableError

No compiled runtime is bound to the current authored task.

Example

from harnest.context import AgentInvocationUnavailableError

try:
    ...
except AgentInvocationUnavailableError as error:
    ...

AgentPendingResponse

A persisted external wait that can be resumed by the owning runtime.

AgentPendingResponse(
    status: Literal['in_progress'],
    session_id: str,
    invocation_id: str,
    pending_action: Mapping[str, str],
) -> None

Fields (— means no declared default):

Field	Type	Default
`status`	`Literal['in_progress']`	`—`
`session_id`	`str`	`—`
`invocation_id`	`str`	`—`
`pending_action`	`Mapping[str, str]`	`—`

Parameters and example

Parameter	Type	Default
`status`	`Literal['in_progress']`	Required
`session_id`	`str`	Required
`invocation_id`	`str`	Required
`pending_action`	`Mapping[str, str]`	Required

from harnest.context import AgentPendingResponse

response = AgentPendingResponse(
    status=...,
    session_id=...,
    invocation_id=...,
    pending_action=...,
)

AgentPendingResponse.as_dict

AgentPendingResponse.as_dict() -> dict[str, Any]

Expose only provider-neutral durable continuation metadata.

Example

from harnest.context import AgentPendingResponse

response: AgentPendingResponse
result = response.as_dict()

AgentResponse

Framework-neutral result returned by an in-process invocation.

AgentResponse(
    output_text: str,
    result: Any,
    events: tuple[RuntimeEvent, ...],
    session_id: str,
    invocation_id: str,
    metadata: Mapping[str, Any],
    usage: TokenUsage | None = None,
) -> None

Fields (— means no declared default):

Field	Type	Default
`output_text`	`str`	`—`
`result`	`Any`	`—`
`events`	`tuple[RuntimeEvent, ...]`	`—`
`session_id`	`str`	`—`
`invocation_id`	`str`	`—`
`metadata`	`Mapping[str, Any]`	`—`
`usage`	`TokenUsage \| None`	`None`

Parameters and example

Parameter	Type	Default
`output_text`	`str`	Required
`result`	`Any`	Required
`events`	`tuple[RuntimeEvent, ...]`	Required
`session_id`	`str`	Required
`invocation_id`	`str`	Required
`metadata`	`Mapping[str, Any]`	Required
`usage`	`TokenUsage \| None`	`None`

from harnest.context import AgentResponse

response = AgentResponse(
    output_text=...,
    result=...,
    events=...,
    session_id=...,
    invocation_id=...,
    metadata=...,
)

AgentResponse.as_dict

AgentResponse.as_dict() -> dict[str, Any]

Return strict JSON without stringifying unsupported output objects.

Example

from harnest.context import AgentResponse

response: AgentResponse
result = response.as_dict()

AgentSession

One persisted session owned by a local in-process runtime identity. Obtain this object from the owning Harnest API; its constructor includes runtime bindings. Fields (— means no declared default):

Field	Type	Default
`id`	`str`	`—`
`user_id`	`str`	`—`

Example

from harnest.context import AgentSession

session: AgentSession  # returned by Harnest, not constructed directly

AgentSession.invoke

async AgentSession.invoke(
    value: Any,
    *,
    metadata: Mapping[str, Any] | None = None,
    request_timeout: float | None = None,
    agent_principal: AgentRuntimePrincipal | None = None,
) -> AgentResponse | AgentPendingResponse

Run one non-streaming turn through the complete runtime pipeline.

Parameters and example

Parameter	Type	Default
`value`	`Any`	Required
`metadata`	`Mapping[str, Any] \| None`	`None`
`request_timeout`	`float \| None`	`None`
`agent_principal`	`AgentRuntimePrincipal \| None`	`None`

from harnest.context import AgentSession

session: AgentSession
response = await session.invoke(value=...)

AgentSession.stream

AgentSession.stream(
    value: Any,
    *,
    metadata: Mapping[str, Any] | None = None,
    request_timeout: float | None = None,
    agent_principal: AgentRuntimePrincipal | None = None,
) -> AsyncIterator[AgentStreamItem]

Stream portable events and a final response with cancellation cleanup.

Parameters and example

Parameter	Type	Default
`value`	`Any`	Required
`metadata`	`Mapping[str, Any] \| None`	`None`
`request_timeout`	`float \| None`	`None`
`agent_principal`	`AgentRuntimePrincipal \| None`	`None`

from harnest.context import AgentSession

session: AgentSession
async for item in session.stream(value=...):
    ...

AgentSessionNotFoundError

An identity-scoped local session does not exist.

Example

from harnest.context import AgentSessionNotFoundError

try:
    ...
except AgentSessionNotFoundError as error:
    ...

AgentStreamItem

One portable runtime event or the validated terminal response.

AgentStreamItem(
    kind: Literal['event', 'completed', 'pending'],
    sequence: int,
    event: RuntimeEvent | None = None,
    response: AgentResponse | None = None,
    pending: AgentPendingResponse | None = None,
) -> None

Fields (— means no declared default):

Field	Type	Default
`kind`	`Literal['event', 'completed', 'pending']`	`—`
`sequence`	`int`	`—`
`event`	`RuntimeEvent \| None`	`None`
`response`	`AgentResponse \| None`	`None`
`pending`	`AgentPendingResponse \| None`	`None`

Parameters and example

Parameter	Type	Default
`kind`	`Literal['event', 'completed', 'pending']`	Required
`sequence`	`int`	Required
`event`	`RuntimeEvent \| None`	`None`
`response`	`AgentResponse \| None`	`None`
`pending`	`AgentPendingResponse \| None`	`None`

from harnest.context import AgentStreamItem

item = AgentStreamItem(kind=..., sequence=...)

AgentStreamItem.as_dict

AgentStreamItem.as_dict() -> dict[str, Any]

Serialize a stable local envelope without importing HTTP contracts.

Example

from harnest.context import AgentStreamItem

item: AgentStreamItem
result = item.as_dict()

ContextRegistration

Metadata declaring the name and order of one context provider.

ContextRegistration(name: str, order: int = 0) -> None

Fields (— means no declared default):

Field	Type	Default
`name`	`str`	`—`
`order`	`int`	`0`

Parameters and example

Parameter	Type	Default
`name`	`str`	Required
`order`	`int`	`0`

from harnest.context import ContextRegistration

registration = ContextRegistration(name=...)

ContextResourceError

Raised when an invocation does not contain a requested resource.

Example

from harnest.context import ContextResourceError

try:
    ...
except ContextResourceError as error:
    ...

ContextUnavailableError

Raised when agent context is accessed outside a Harnest invocation.

Example

from harnest.context import ContextUnavailableError

try:
    ...
except ContextUnavailableError as error:
    ...

LocalAgentRuntime

Invoke a final compiled runtime driver without an HTTP round trip.

LocalAgentRuntime(
    driver: RuntimeDriver,
    *,
    user_id: str,
    transport: str = 'local',
    trigger: Literal['agent', 'cron', 'user'] = 'user',
    request_timeout: float = 300,
    identity_namespace: str | None = None,
    metadata: Mapping[str, Any] | None = None,
) -> None

Parameters and example

Parameter	Type	Default
`driver`	`RuntimeDriver`	Required
`user_id`	`str`	Required
`transport`	`str`	`'local'`
`trigger`	`Literal['agent', 'cron', 'user']`	`'user'`
`request_timeout`	`float`	`300`
`identity_namespace`	`str \| None`	`None`
`metadata`	`Mapping[str, Any] \| None`	`None`

from harnest.context import LocalAgentRuntime

runtime = LocalAgentRuntime(driver=..., user_id=...)

LocalAgentRuntime.user_id

Return the session owner selected by the local caller.

Example

from harnest.context import LocalAgentRuntime

runtime: LocalAgentRuntime
value = runtime.user_id

LocalAgentRuntime.create_session

async LocalAgentRuntime.create_session(
    *,
    state: Mapping[str, Any] | None = None,
    session_id: str | None = None,
    reuse_existing: bool = False,
) -> AgentSession

Create one persisted session under the configured local identity.

Parameters and example

Parameter	Type	Default
`state`	`Mapping[str, Any] \| None`	`None`
`session_id`	`str \| None`	`None`
`reuse_existing`	`bool`	`False`

from harnest.context import LocalAgentRuntime

runtime: LocalAgentRuntime
session = await runtime.create_session()

LocalAgentRuntime.open_session

async LocalAgentRuntime.open_session(session_id: str) -> AgentSession

Open an existing session without revealing another owner’s records.

Parameters and example

Parameter	Type	Default
`session_id`	`str`	Required

from harnest.context import LocalAgentRuntime

runtime: LocalAgentRuntime
session = await runtime.open_session(session_id=...)

MemoryContext

Access explicit memories across sessions within one application/user scope.

MemoryContext(active: Any, namespace: str = 'default') -> None

Parameters and example

Parameter	Type	Default
`active`	`Any`	Required
`namespace`	`str`	`'default'`

from harnest.context import MemoryContext

context = MemoryContext(active=...)

MemoryContext.namespace

MemoryContext.namespace(name: str) -> MemoryContext

Select a logical collection without changing application/user ownership.

Parameters and example

Parameter	Type	Default
`name`	`str`	Required

from harnest.context import MemoryContext

context: MemoryContext
context = context.namespace(name=...)

MemoryContext.put

async MemoryContext.put(
    key: str,
    content: str,
    *,
    metadata: Optional[Mapping[str, Any]] = None,
    expires_at: float | None = None,
    expected_revision: str | None = None,
) -> harnest.memory.MemoryRecord

Deliberately save or replace a memory, recording invocation provenance.

Parameters and example

Parameter	Type	Default
`key`	`str`	Required
`content`	`str`	Required
`metadata`	`Optional[Mapping[str, Any]]`	`None`
`expires_at`	`float \| None`	`None`
`expected_revision`	`str \| None`	`None`

from harnest.context import MemoryContext

context: MemoryContext
record = await context.put(key=..., content=...)

MemoryContext.get

async MemoryContext.get(key: str) -> harnest.memory.MemoryRecord | None

Read a scoped key without adding it to model context.

Parameters and example

Parameter	Type	Default
`key`	`str`	Required

from harnest.context import MemoryContext

context: MemoryContext
record = await context.get(key=...)

MemoryContext.list

async MemoryContext.list(*, limit: int = 20, after: str | None = None) -> harnest.memory.MemoryPage

List a bounded page of explicit memories across this user’s sessions.

Parameters and example

Parameter	Type	Default
`limit`	`int`	`20`
`after`	`str \| None`	`None`

from harnest.context import MemoryContext

context: MemoryContext
page = await context.list()

MemoryContext.search

async MemoryContext.search(query: str, *, limit: int = 20, after: str | None = None) -> harnest.memory.MemoryPage

Search literal text on explicit request, without model calls.

Parameters and example

Parameter	Type	Default
`query`	`str`	Required
`limit`	`int`	`20`
`after`	`str \| None`	`None`

from harnest.context import MemoryContext

context: MemoryContext
page = await context.search(query=...)

MemoryContext.delete

async MemoryContext.delete(key: str, *, expected_revision: str | None = None) -> bool

Explicitly forget a memory and its provider index references.

Parameters and example

Parameter	Type	Default
`key`	`str`	Required
`expected_revision`	`str \| None`	`None`

from harnest.context import MemoryContext

context: MemoryContext
result = await context.delete(key=...)

ScopedAssets

Named asset capabilities restricted to one authenticated invocation. Obtain this object from the owning Harnest API; its constructor includes runtime bindings.

Example

from harnest.context import ScopedAssets

assets: ScopedAssets  # returned by Harnest, not constructed directly

ScopedAssets.call

ScopedAssets.__call__(store: str) -> 'ScopedAssets'

Select one named store without exposing its backing implementation.

Parameters and example

Parameter	Type	Default
`store`	`str`	Required

from harnest.context import ScopedAssets

assets: ScopedAssets
assets = assets(store=...)

ScopedAssets.save

async ScopedAssets.save(
    *,
    media_type: str,
    chunks: AsyncIterable[bytes],
    metadata: AssetMediaMetadata | None = None,
    retention_seconds: float | None = None,
    path: str | None = None,
    label: str | None = None,
    store: str | None = None,
) -> AssetRef

Persist streamed bytes and return a reference carrying store routing.

Parameters and example

Parameter	Type	Default
`media_type`	`str`	Required
`chunks`	`AsyncIterable[bytes]`	Required
`metadata`	`AssetMediaMetadata \| None`	`None`
`retention_seconds`	`float \| None`	`None`
`path`	`str \| None`	`None`
`label`	`str \| None`	`None`
`store`	`str \| None`	`None`

from harnest.context import ScopedAssets

assets: ScopedAssets
ref = await assets.save(media_type=..., chunks=...)

ScopedAssets.stat

async ScopedAssets.stat(reference: Any, *, store: str | None = None) -> AssetRecord

Return safe metadata for an owned asset or fail closed.

Parameters and example

Parameter	Type	Default
`reference`	`Any`	Required
`store`	`str \| None`	`None`

from harnest.context import ScopedAssets

assets: ScopedAssets
record = await assets.stat(reference=...)

ScopedAssets.open

ScopedAssets.open(reference: Any, *, store: str | None = None) -> AsyncIterator[bytes]

Stream owned bytes without exposing the backing storage object.

Parameters and example

Parameter	Type	Default
`reference`	`Any`	Required
`store`	`str \| None`	`None`

from harnest.context import ScopedAssets

assets: ScopedAssets
result = assets.open(reference=...)

ScopedAssets.get

async ScopedAssets.get(reference: Any, *, store: str | None = None, max_bytes: int = 10485760) -> bytes

Read a bounded asset for APIs that require an in-memory payload.

Parameters and example

Parameter	Type	Default
`reference`	`Any`	Required
`store`	`str \| None`	`None`
`max_bytes`	`int`	`10485760`

from harnest.context import ScopedAssets

assets: ScopedAssets
result = await assets.get(reference=...)

ScopedAssets.delete

async ScopedAssets.delete(reference: Any, *, store: str | None = None) -> bool

Delete an owned asset without revealing another scope’s content.

Parameters and example

Parameter	Type	Default
`reference`	`Any`	Required
`store`	`str \| None`	`None`

from harnest.context import ScopedAssets

assets: ScopedAssets
result = await assets.delete(reference=...)

ScopedAssets.url

async ScopedAssets.url(reference: Any, *, expires_in: float, store: str | None = None) -> str

Ask an explicitly URL-capable storage for a fresh temporary URL.

Parameters and example

Parameter	Type	Default
`reference`	`Any`	Required
`expires_in`	`float`	Required
`store`	`str \| None`	`None`

from harnest.context import ScopedAssets

assets: ScopedAssets
result = await assets.url(reference=..., expires_in=...)

SessionContext

Provide JSON-safe access to the current session’s application-data lane. Obtain this object from the owning Harnest API; its constructor includes runtime bindings.

Example

from harnest.context import SessionContext

context: SessionContext  # returned by Harnest, not constructed directly

SessionContext.get

async SessionContext.get(key: str, default: Any = None) -> Any

Return a detached value without exposing mutable store-owned state.

Parameters and example

Parameter	Type	Default
`key`	`str`	Required
`default`	`Any`	`None`

from harnest.context import SessionContext

context: SessionContext
result = await context.get(key=...)

SessionContext.set

async SessionContext.set(key: str, value: Any) -> None

Persist one value without projecting it into framework model state.

Parameters and example

Parameter	Type	Default
`key`	`str`	Required
`value`	`Any`	Required

from harnest.context import SessionContext

context: SessionContext
await context.set(key=..., value=...)

SessionContext.update

async SessionContext.update(values: Mapping[str, Any]) -> None

Persist a bounded mapping in one lease-owned write.

Parameters and example

Parameter	Type	Default
`values`	`Mapping[str, Any]`	Required

from harnest.context import SessionContext

context: SessionContext
await context.update(values=...)

SessionContext.delete

async SessionContext.delete(key: str) -> bool

Delete one value and report whether the current namespace contained it.

Parameters and example

Parameter	Type	Default
`key`	`str`	Required

from harnest.context import SessionContext

context: SessionContext
result = await context.delete(key=...)

SessionContext.namespace

SessionContext.namespace(name: str) -> 'SessionContext'

Return a nested view so teams and plugins can avoid key collisions.

Parameters and example

Parameter	Type	Default
`name`	`str`	Required

from harnest.context import SessionContext

context: SessionContext
context = context.namespace(name=...)

SessionDataError

Raised when application session data violates its scoped contract.

Example

from harnest.context import SessionDataError

try:
    ...
except SessionDataError as error:
    ...

StorageContext

Resolve custom storage without exposing sessions or checkpoints.

StorageContext()

Example

from harnest.context import StorageContext

context = StorageContext()

StorageContext.call

StorageContext.__call__(name: str, expected_type: type[Any] | None = None) -> Any

Return one named custom resource for concise authored access.

Parameters and example

Parameter	Type	Default
`name`	`str`	Required
`expected_type`	`type[Any] \| None`	`None`

from harnest.context import StorageContext

context: StorageContext
result = context(name=...)

StorageContext.resource

StorageContext.resource(name: str, expected_type: type[Any] | None = None) -> Any

Resolve a custom store while keeping the registry non-enumerable.

Parameters and example

Parameter	Type	Default
`name`	`str`	Required
`expected_type`	`type[Any] \| None`	`None`

from harnest.context import StorageContext

context: StorageContext
result = context.resource(name=...)

activate_agent_scope

Narrow managed identity to the framework component currently executing.

activate_agent_scope(agent_name: str | None) -> Iterator[AgentContext | None]

Parameters and example

Parameter	Type	Default
`agent_name`	`str \| None`	Required

from harnest.context import activate_agent_scope

with activate_agent_scope(agent_name=...):
    ...

current

Return the active managed invocation context.

current() -> AgentContext

Example

from harnest.context import current

context = current()

derive_agent_context

Create a child view that shares only its parent’s revocable capabilities.

derive_agent_context(active: AgentContext, *, agent_name: str) -> AgentContext

Parameters and example

Parameter	Type	Default
`active`	`AgentContext`	Required
`agent_name`	`str`	Required

from harnest.context import derive_agent_context

context = derive_agent_context(active=..., agent_name=...)

provider

Declare one invocation-scoped resource on the public context namespace.

provider(name: str, *, order: int = 0) -> Callable[[_ProviderT], _ProviderT]

Parameters and example

Parameter	Type	Default
`name`	`str`	Required
`order`	`int`	`0`

from harnest.context import provider

@provider(name=...)
def my_function():
    ...

resource

Resolve one explicitly published invocation resource.

resource(name: str, expected_type: type[Any] | None = None) -> Any

Parameters and example

Parameter	Type	Default
`name`	`str`	Required
`expected_type`	`type[Any] \| None`	`None`

from harnest.context import resource

result = resource(name=...)

SandboxHandle

Access this facade through context.sandboxes["name"]; its implementation type is not a public import. A revocable agent-and-invocation-bound execution capability.

SandboxHandle.execute

SandboxHandle.execute(code: str, *, input_files: tuple[SandboxFile, ...] = ()) -> SandboxResult

Execute tool-authored code with immutable provider policy and identity.

Parameters and example

Parameter	Type	Default
`code`	`str`	Required
`input_files`	`tuple[SandboxFile, ...]`	`()`

from harnest import context

result = context.sandboxes["name"].execute(code=...)

SandboxHandle.aexecute

async SandboxHandle.aexecute(code: str, *, input_files: tuple[SandboxFile, ...] = ()) -> SandboxResult

Keep blocking providers off the event loop and revoke cancelled work.

Parameters and example

Parameter	Type	Default
`code`	`str`	Required
`input_files`	`tuple[SandboxFile, ...]`	`()`

from harnest import context

result = await context.sandboxes["name"].aexecute(code=...)

​Invocation capabilities

​Memory operations

​Session operations

​Exports

​AgentContext

​AgentContext.resource

​AgentContext.is_root

​AgentContinuationUnsupportedError

​AgentInvocationTimeout

​AgentInvocationUnavailableError

​AgentPendingResponse

​AgentPendingResponse.as_dict

​AgentResponse

​AgentResponse.as_dict

​AgentSession

​AgentSession.invoke

​AgentSession.stream

​AgentSessionNotFoundError

​AgentStreamItem

​AgentStreamItem.as_dict

​ContextRegistration

​ContextResourceError

​ContextUnavailableError

​LocalAgentRuntime

​LocalAgentRuntime.user_id

​LocalAgentRuntime.create_session

​LocalAgentRuntime.open_session

​MemoryContext

​MemoryContext.namespace

​MemoryContext.put

​MemoryContext.get

​MemoryContext.list

​MemoryContext.search

​MemoryContext.delete

​ScopedAssets

​ScopedAssets.call

​ScopedAssets.save

​ScopedAssets.stat

​ScopedAssets.open

​ScopedAssets.get

​ScopedAssets.delete

​ScopedAssets.url

​SessionContext

​SessionContext.get

​SessionContext.set

​SessionContext.update

​SessionContext.delete

​SessionContext.namespace

​SessionDataError

​StorageContext

​StorageContext.call

​StorageContext.resource

​activate_agent_scope

​current

​derive_agent_context

​provider

​resource

​SandboxHandle

​SandboxHandle.execute

​SandboxHandle.aexecute

Invocation capabilities

Memory operations

Session operations

Exports

AgentContext

AgentContext.resource

AgentContext.is_root

AgentContinuationUnsupportedError

AgentInvocationTimeout

AgentInvocationUnavailableError

AgentPendingResponse

AgentPendingResponse.as_dict

AgentResponse

AgentResponse.as_dict

AgentSession

AgentSession.invoke

AgentSession.stream

AgentSessionNotFoundError

AgentStreamItem

AgentStreamItem.as_dict

ContextRegistration

ContextResourceError

ContextUnavailableError

LocalAgentRuntime

LocalAgentRuntime.user_id

LocalAgentRuntime.create_session

LocalAgentRuntime.open_session

MemoryContext

MemoryContext.namespace

MemoryContext.put

MemoryContext.get

MemoryContext.list

MemoryContext.search

MemoryContext.delete

ScopedAssets

ScopedAssets.call

ScopedAssets.save

ScopedAssets.stat

ScopedAssets.open

ScopedAssets.get

ScopedAssets.delete

ScopedAssets.url

SessionContext

SessionContext.get

SessionContext.set

SessionContext.update

SessionContext.delete

SessionContext.namespace

SessionDataError

StorageContext

StorageContext.call

StorageContext.resource

activate_agent_scope

current

derive_agent_context

provider

resource

SandboxHandle

SandboxHandle.execute

SandboxHandle.aexecute