App facade (tai42_contract.app)

class AppAccounts(Protocol)

active_provider(self, name: str) -> IdentityProvider | None

class AppAdmin(Protocol)

reload_mcp(self, title: str) -> dict[str, Any]

deregister_mcp(self, title: str) -> dict[str, Any]

reload_config(self) -> dict[str, Any]

tool_reloader(self, kind: str) -> Callable[..., Any]

async run_tool_reload(self, kind: str, action: str, name: str) -> dict[str, Any]

reload_failed_mcps(self) -> list[dict[str, Any]]

list_failed_mcps(self) -> list[dict[str, Any]]

live_mcp_status(self) -> dict[str, Any]

live_manifest: dict[str, Any]

class AppAgents(Protocol)

agent(
    self,
    name: str,
    tags: set[str] | None = None,
    meta: dict[str, Any] | None = None,
) -> Callable[[type[_AgentT]], type[_AgentT]]

get_agent(self, name: str) -> Agent

all_agents(self) -> dict[str, Agent]

class AppBackends(Protocol)

register_backend(self, cls: type[Backend] | None = None) -> Callable[[type[Backend]], type[Backend]] | type[Backend]

backend: Backend | None

class AppBackup(Protocol)

register_section(
    self,
    name: str,
    exporter: Callable[[], Any],
    importer: Callable[[Any], Any],
    *,
    secret: bool = False,
) -> None

sections(self) -> list[BackupSectionInfo]

export_section(self, name: str) -> Any

import_section(self, name: str, payload: Any) -> Any

class AppChannels(Protocol)

register(self, name: str, channel: Channel) -> None

get(self, name: str) -> Channel

names(self) -> list[str]

async handle_inbound_answer(
    self,
    *,
    channel_id: str,
    correlation_key: str,
    answer: Any,
    store: CorrelationStore,
    bridge: InboundBridge,
) -> InboundAnswerResult

async record_send_receipt(
    self,
    channel: str,
    provider_message_id: str,
    status: DeliveryReceipt,
    *,
    errors: Any = None,
) -> bool

class AppClients(Protocol)

client_ctx(
    self,
    client_cls: type[BaseClient[ClientT]],
    settings: Any = None,
    *,
    fresh: bool = False,
    **kwargs: Any,
) -> AbstractAsyncContextManager[ClientT]

async shutdown_clients(self) -> None

class AppConfig(Protocol)

config_manager: ConfigManager

class AppConnectors(Protocol)

register_connector(self, descriptor: ProviderDescriptor) -> None

token_store: ConnectorTokenStore

async resolve_connection_auth(self, connection_id: str, provider_id: str, sub_service: str) -> ResolvedConnectionAuth | None

class AppConversations(Protocol)

async accept(
    self,
    channel: str,
    our_identity: str,
    client_address: str,
    cap_key: str,
    text: str,
    provider_message_id: str,
    params: dict[str, str] | None = None,
    form: dict[str, Any] | None = None,
    attachments: list[MediaItem] | None = None,
    location: LocationElement | None = None,
    locale: str | None = None,
) -> str

async record_delivery_status(self, channel: str, provider_message_id: str, status: DeliveryReceipt) -> None

async pending_messages(self, thread_id: str, *, after: str) -> list[PendingMessage]

register_target_validator(self, target_kind: ConversationTargetKind, validator: TargetBindValidator) -> None

class AppExtensions(Protocol)

extension(
    self,
    f: Callable[..., Any] | None = None,
    *,
    kind: ExtensionKind,
    name: str | None = None,
    requires_body_locality: bool = False,
) -> Callable[..., Any]

available_extensions(self) -> list[dict[str, str]]

class AppHttp(Protocol)

middleware(self, cls: type[Any] | None = None, **options: Any) -> Callable[..., Any]

custom_route(
    self,
    path: str,
    methods: list[str],
    name: str | None = None,
    include_in_schema: bool = True,
    *,
    summary: str,
    tags: list[str],
    response_model: type[BaseModel] | None,
    request_model: type[BaseModel] | None = None,
    query_model: type[BaseModel] | None = None,
    authed: bool | None = None,
    destructive: bool = False,
    action: RouteAction | None = None,
    declared: DeclaredRouteMetadata | None = None,
    no_body_reason: str | None = None,
    enveloped: bool = True,
) -> Callable[[Callable[[Request], Awaitable[Response]]], Callable[[Request], Awaitable[Response]]]

use_raw_path_key(self, path_prefix: str) -> None

mount_base(self) -> str

class AppInteractions(Protocol)

check_answer(self, question: QuestionFormat, answer: Any) -> None

async assert_resume_authorized(self, interaction_id: str) -> None

assert_delivery_authorized(self, completion_id: str | None) -> None

redelivery_horizon_seconds(self) -> int

visit: Visit

park_answer(self, outcome: VisitOutcome) -> Any

async normalise_started(self, value: Any) -> VisitOutcome

async list_parked(self) -> list[ParkedEntry]

async list_parked_for(self, context: StateContext | None) -> list[ParkedEntry]

current_fire_identity(self) -> tuple[str, str] | None

bound_execution_identity_for_fire(self, execution_key: str, fingerprint: str) -> AbstractAsyncContextManager[Any]

async resume_parked(self, interaction_id: str, payload: Any = ...) -> VisitOutcome

async cancel_parked(self, ids: list[str]) -> VisitOutcome

ask: Ask

class AppLifecycle(Protocol)

on_startup(self, func: Callable[[], Any]) -> Callable[[], Any]

on_shutdown(self, func: Callable[[], Any]) -> Callable[[], Any]

on_reload(self, func: Callable[[], Any]) -> Callable[[], Any]

on_post_swap(self, func: Callable[[], Any]) -> Callable[[], Any]

on_fleet_op_applied(self, func: Callable[[str], Any]) -> Callable[[str], Any]

async wait_until_ready(self) -> None

class AppMonitoring(Protocol)

register_monitoring(self, builder: Callable[..., Any] | None = None) -> Callable[..., Any]

active: Monitoring

class AppPresets(Protocol)

async bind(
    self,
    base_tool: str,
    fixed_kwargs: dict[str, Any],
    *,
    name: str,
    description: str = '',
    tags: list[str] | None = None,
    output_schema: dict[str, Any] | None = None,
) -> Tool

async create(
    self,
    name: str,
    base_tool: str,
    description: str,
    fixed_kwargs: dict[str, Any],
    *,
    input_schema: dict[str, Any] | None = None,
    output_schema: dict[str, Any] | None = None,
    extensions: list[list[ExtensionElement]] | None = None,
    state_binding: StateBinding | None = None,
    tags: list[str] | None = None,
) -> dict[str, Any]

async save_version(
    self,
    name: str,
    *,
    fixed_kwargs: dict[str, Any] | None = None,
    input_schema: dict[str, Any] | CarryForward | None = CARRY_FORWARD,
    output_schema: dict[str, Any] | None = None,
    output_schema_provided: bool = False,
    description: str | None = None,
    extensions: list[list[ExtensionElement]] | None = None,
    state_binding: StateBinding | CarryForward | None = CARRY_FORWARD,
    tags: list[str] | None = None,
) -> dict[str, Any]

register_write_validator(self, base_tool: str, validator: PresetWriteValidator) -> None

register_input_schema_support(self, base_tool: str, support: PresetInputSchemaSupport) -> None

input_schema_support(self, base_tool: str) -> PresetInputSchemaSupport | None

register_registration_tier(self, base_tool: str, tier: RouteAction) -> None

registration_tier(self, base_tool: str) -> RouteAction | None

async get_active_versioned_body(self, name: str) -> tuple[int, PresetBody]

async used_by(self, name: str) -> list[str]

register_seed(self, seed: PresetSeed) -> None

store: PresetStore

class AppSandboxes(Protocol)

register_sandbox(self, cls: type[Sandbox]) -> type[Sandbox]

sandbox: Sandbox | None

require_sandbox(self) -> Sandbox

sandbox_policy(self) -> SandboxPolicy

class AppStates(Protocol)

async list_declarations(self) -> list[StateDeclaration]

async get_declaration(self, name: str) -> StateDeclaration | None

async put_declaration(self, decl: StateDeclaration) -> StateDeclaration

async delete_declaration(self, name: str) -> None

async stats(self, name: str) -> dict[str, Any]

async list_templates(self) -> list[StateTemplateDocument]

async get_template(self, name: str) -> StateTemplateDocument | None

async put_template(self, doc: StateTemplateDocument, *, replace: bool) -> StateTemplateDocument

async delete_template(self, name: str) -> None

async list_attachments(self, state: str | None = None, *, template: str | None = None) -> list[dict[str, Any]]

async attach(self, state: str, template: str, body: AttachBody) -> None

async update_attachment_declarations(
    self,
    state: str,
    template: str,
    declarations: dict[str, Any],
    *,
    options: dict[str, Any] | None = None,
) -> None

async detach(self, state: str, template: str) -> None

async read(self, state: str, subject: StateSubject) -> StateRecord | None

async replace(
    self,
    state: str,
    subject: StateSubject,
    data: dict[str, Any],
    *,
    origin: WriteOrigin,
) -> StateRecord

async merge(
    self,
    state: str,
    subject: StateSubject,
    patch: dict[str, Any],
    *,
    origin: WriteOrigin,
) -> StateRecord

async apply(
    self,
    state: str,
    subject: StateSubject,
    ops: list[dict[str, Any]],
    *,
    op_id: str | None,
    origin: WriteOrigin,
) -> ApplyResult

async eval_template_jq(self, state: str, subject: StateSubject, name: str, params: dict[str, Any]) -> TemplateJqResult

async apply_template_jq(
    self,
    state: str,
    subject: StateSubject,
    name: str,
    input_: Any,
    *,
    op_id: str | None,
    origin: WriteOrigin,
) -> TemplateJqApplyResult

async erase(self, state: str, subject: StateSubject, *, origin: WriteOrigin) -> None

async fold(
    self,
    state: str,
    subject: StateSubject,
    into: StateSubject,
    mode: str,
    *,
    origin: WriteOrigin,
) -> dict[str, Any]

async list_subjects(
    self,
    state: str,
    *,
    kind: str | None = None,
    limit: int | None = None,
    cursor: str | None = None,
) -> dict[str, Any]

async search(
    self,
    state: str,
    filters: dict[str, Any],
    *,
    limit: int | None = None,
    cursor: str | None = None,
) -> dict[str, Any]

async writes(
    self,
    state: str,
    subject: StateSubject,
    *,
    limit: int | None = None,
    cursor: str | None = None,
) -> WritesPage

async prune_expired(self) -> dict[str, int]