Rust-port-only public symbols with no Python-canonical counterpart. Both the surface
diff (folded keys) and the signature diff (unfolded per-class keys) read this file, so
mixin-flatten methods appear here under BOTH agentbase-family.<m> (folded) and
signalwire.core.agent_base.AgentBase.<m> (unfolded) forms.
NOTE:
signalwire.rest.**Resource/*Namespaceentries are FROZEN pending the spec-driven REST base+subclass parity pass — do not delete/rename them here.
agentbase-family.add_internal_filler_for: Rust-only granular per-target adder; canonical add_internal_filler (Python-matching) also present.
agentbase-family.build_ai_verb: Rust-only helper assembling the AI verb JSON from headers; Python builds it inline during render. No reference twin.
agentbase-family.clone_for_request: Rust-only: the derive(Clone) dynamic-config pattern clones the agent per request. No reference twin.
agentbase-family.list_tool_names: Rust-only read accessor returning registered SWAIG tool names; Python has no such enumerator on AgentBase.
agentbase-family.refresh_context_tools: Rust-only: re-syncs context-derived tools into the registry (explicit borrow-checker step); Python does this implicitly.
agentbase-family.service: Rust-only accessor returning the composed &Service (SWMLService); Python inherits SWMLService directly so no accessor exists.
agentbase-family.service_mut: Rust-only &mut companion to service() (borrow-checker idiom); no Python analogue.
agentbase-family.set_internal_fillers_map: Rust-only granular map setter; canonical set_internal_fillers (Python-matching) also present.
agentbase-family.set_language_engine: Rust-only granular single-field language setter; Python configures via add_language/set_language_params (both present).
agentbase-family.set_language_fillers: Rust-only granular single-field language setter; see set_language_engine.
agentbase-family.set_language_model: Rust-only granular single-field language setter; see set_language_engine.
agentbase-family.set_pattern_hint_hint: Rust-only granular pattern-hint component setter; canonical add_pattern_hint (Python-matching) also present.
agentbase-family.set_pattern_hint_ignore_case: Rust-only granular pattern-hint component setter; see set_pattern_hint_hint.
agentbase-family.set_pattern_hint_replace: Rust-only granular pattern-hint component setter; see set_pattern_hint_hint.
agentbase-family.set_signing_key: Rust-only explicit setter for the webhook signing key; Python sets via constructor/private attr, no public setter.
agentbase-family.set_webhook_url: Rust-only explicit setter for the agent webhook URL; no equivalent single-field public setter in Python.
agentbase-family.signing_key: Rust-only accessor/builder for the webhook signing key; Python holds it as a private attr with no public accessor.
agentbase-family.sip_usernames: Rust-only read accessor returning registered SIP usernames; Python registers via register_sip_username (present) but exposes no list accessor.
signalwire.AgentBase: Rust idiom: pub use exposes types under signalwire::Foo so users can use signalwire::AgentBase directly. Python lists these too but the dotted-path enumerator records them differently.
signalwire.AgentOptions: Rust idiom: pub use exposes types under signalwire::Foo so users can use signalwire::AgentBase directly. Python lists these too but the dotted-path enumerator records them differently.
signalwire.AgentServer: Rust idiom: pub use exposes types under signalwire::Foo so users can use signalwire::AgentBase directly. Python lists these too but the dotted-path enumerator records them differently.
signalwire.ParseLevelError: top-level re-export of the typed error returned by "level".parse::<logging::Level>() (defined in signalwire::logging), surfaced at the crate root so callers can name it as signalwire::ParseLevelError. Python parses the log level with a silent getattr(logging, level.upper(), logging.INFO) fallback and has no equivalent typed error. The Rust FromStr trait requires an associated Err type, so the error is intrinsic to the idiomatic parse API.
signalwire.SWMLService: Rust idiom: pub use exposes types under signalwire::Foo so users can use signalwire::AgentBase directly. Python lists these too but the dotted-path enumerator records them differently.
signalwire.SkillSpec: top-level re-export: Rust exposes SkillSpec at the crate root for ergonomic signalwire::SkillSpec access; Python's equivalent is internal to the skill registry. The struct itself is a Rust idiom — Python uses raw class objects passed to register_skill(...).
signalwire.SkillSpec.init: top-level re-export: Rust exposes SkillSpec at the crate root for ergonomic signalwire::SkillSpec access; Python's equivalent is internal to the skill registry. The struct itself is a Rust idiom — Python uses raw class objects passed to register_skill(...).
signalwire.agent_server.AgentServer.get_agent_mut: Rust idiom of explicit accessor methods (host(), port(), …) and rust-private serve_static (which serve_static_files now aliases for Python parity).
signalwire.agent_server.AgentServer.handle_request: Rust idiom of explicit accessor methods (host(), port(), …) and rust-private serve_static (which serve_static_files now aliases for Python parity).
signalwire.agent_server.AgentServer.host: Rust idiom of explicit accessor methods (host(), port(), …) and rust-private serve_static (which serve_static_files now aliases for Python parity).
signalwire.agent_server.AgentServer.is_sip_routing_enabled: Rust idiom of explicit accessor methods (host(), port(), …) and rust-private serve_static (which serve_static_files now aliases for Python parity).
signalwire.agent_server.AgentServer.port: Rust idiom of explicit accessor methods (host(), port(), …) and rust-private serve_static (which serve_static_files now aliases for Python parity).
signalwire.agent_server.AgentServer.serve_static: Rust idiom of explicit accessor methods (host(), port(), …) and rust-private serve_static (which serve_static_files now aliases for Python parity).
signalwire.agent_server.AgentServer.sip_username_mapping: Rust idiom of explicit accessor methods (host(), port(), …) and rust-private serve_static (which serve_static_files now aliases for Python parity).
signalwire.agents.bedrock.BedrockAgent.agent: Read-only / mutable accessors that surface internal Bedrock state. Python uses attribute access (self._voice_id) directly.
signalwire.agents.bedrock.BedrockAgent.agent_mut: Read-only / mutable accessors that surface internal Bedrock state. Python uses attribute access (self._voice_id) directly.
signalwire.agents.bedrock.BedrockAgent.max_tokens: Read-only / mutable accessors that surface internal Bedrock state. Python uses attribute access (self._voice_id) directly.
signalwire.agents.bedrock.BedrockAgent.render_swml: Read-only / mutable accessors that surface internal Bedrock state. Python uses attribute access (self._voice_id) directly.
signalwire.agents.bedrock.BedrockAgent.temperature: Read-only / mutable accessors that surface internal Bedrock state. Python uses attribute access (self._voice_id) directly.
signalwire.agents.bedrock.BedrockAgent.top_p: Read-only / mutable accessors that surface internal Bedrock state. Python uses attribute access (self._voice_id) directly.
signalwire.agents.bedrock.BedrockAgent.voice_id: Read-only / mutable accessors that surface internal Bedrock state. Python uses attribute access (self._voice_id) directly.
signalwire.core.agent_base.AgentBase.add_function_include: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.add_hint: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.add_hints: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.add_internal_filler: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.add_internal_filler_for: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.add_language: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.add_mcp_server: These methods exist in Python's AgentBase too (via a mixin — here AIConfigMixin.add_mcp_server). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase in addition to projecting onto the originating mixin. Python has the same surface.
signalwire.core.agent_base.AgentBase.add_pattern_hint: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.add_pronunciation: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.add_skill: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.as_router: These methods exist in Python's AgentBase too (via a mixin — here WebMixin.as_router). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase in addition to projecting onto the originating mixin. Python has the same surface.
signalwire.core.agent_base.AgentBase.build_ai_verb: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.contexts: These methods exist in Python's AgentBase too (via a mixin — here PromptMixin.contexts). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase in addition to projecting onto the originating mixin. Python has the same surface.
signalwire.core.agent_base.AgentBase.define_contexts: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.define_tools: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.enable_debug_events: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.get_basic_auth_credentials: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.get_language_params: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.get_prompt: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.handle_request: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.handle_serverless_request: These methods exist in Python's AgentBase too (via a mixin — here ServerlessMixin.handle_serverless_request). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase in addition to projecting onto the originating mixin. Python has the same surface.
signalwire.core.agent_base.AgentBase.has_skill: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.manual_set_proxy_url: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.prompt_add_section: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.prompt_add_subsection: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.prompt_add_to_section: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.prompt_has_section: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.register_routing_callback: These methods exist in Python's AgentBase too (via a mixin — here WebMixin.register_routing_callback). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase in addition to projecting onto the originating mixin. Python has the same surface.
signalwire.core.agent_base.AgentBase.remove_skill: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.serve: These methods exist in Python's AgentBase too (via a mixin — here WebMixin.serve). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase in addition to projecting onto the originating mixin. Python has the same surface.
signalwire.core.agent_base.AgentBase.service: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.service_mut: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.set_dynamic_config_callback: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.set_function_includes: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.set_global_data: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.set_internal_fillers: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.set_internal_fillers_map: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.set_language_engine: rust-builder-method — set the TTS engine on the most-recently-added language; Python passes engine= to add_language.
signalwire.core.agent_base.AgentBase.set_language_fillers: rust-builder-method — attach speech_fillers / function_fillers (or the deprecated combined fillers) to the most-recently-added language; Python passes speech_fillers= / function_fillers= to add_language.
signalwire.core.agent_base.AgentBase.set_language_model: rust-builder-method — set the TTS model on the most-recently-added language; Python passes model= to add_language.
signalwire.core.agent_base.AgentBase.set_language_params: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.set_languages: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.set_multilingual: These methods exist in Python's AgentBase too (via the AIConfigMixin). The Rust port hangs set_multilingual directly off AgentBase (and projects it onto AIConfigMixin), so the per-symbol enumerator also emits it under signalwire.core.agent_base.AgentBase. Python has the same surface.
signalwire.core.agent_base.AgentBase.set_native_functions: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.set_param: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.set_params: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.set_pattern_hint_hint: rust-builder-method — set the hint (match text) on the most-recently-added structured pattern hint; Python passes hint= to add_pattern_hint.
signalwire.core.agent_base.AgentBase.set_pattern_hint_ignore_case: rust-builder-method — set the ignore_case flag on the most-recently-added structured pattern hint; Python passes ignore_case= to add_pattern_hint.
signalwire.core.agent_base.AgentBase.set_pattern_hint_replace: rust-builder-method — set the replace (replacement text) on the most-recently-added structured pattern hint; Python passes replace= to add_pattern_hint.
signalwire.core.agent_base.AgentBase.set_post_prompt: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.set_post_prompt_llm_params: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.set_prompt_llm_params: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.set_prompt_pom: prompt_mixin_lifted: Rust rolls up PromptMixin onto AgentBase; Python keeps these on PromptMixin (mirrors tool_mixin_lifted pattern).
signalwire.core.agent_base.AgentBase.set_prompt_text: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.set_pronunciations: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.set_signing_key: rust-explicit-setter — Rust exposes set_signing_key(Option<&str>) so callers can configure the webhook signature key after construction; Python relies on attribute assignment which doesn't surface as a method in the signature inventory.
signalwire.core.agent_base.AgentBase.set_webhook_url: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.). Python has the same surface.
signalwire.core.agent_base.AgentBase.tool: These methods exist in Python's AgentBase too (via a mixin — here ToolMixin.tool). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase in addition to projecting onto the originating mixin. Python has the same surface.
signalwire.core.agent_base.AgentBase.update_global_data: These methods exist in Python's AgentBase too (often via a mixin). The Rust port hangs them directly off AgentBase, so the per-symbol enumerator emits them under signalwire.core.agent_base.AgentBase rather than under the originating mixin (signalwire.core.mixins.*). Python has the same surface.
signalwire.core.agent_base.AgentBase.validate_tool_token: state_mixin_lifted: Rust rolls up StateMixin onto AgentBase; Python keeps validate_tool_token on StateMixin (mirrors tool_mixin_lifted pattern).
signalwire.core.data_map.DataMap.for_each: Rust merges Python's create_simple_api_tool / create_expression_tool helpers into DataMap-method form. for_each is the Rust naming of foreach (Python uses snake_case, Rust uses for_each to avoid conflict with the for keyword family).
signalwire.core.function_result.FunctionResult.to_json: to_json / to_value are serde serialization helpers; with_response is Rust's idiomatic alternative to Python's FunctionResult(response=...) constructor pattern.
signalwire.core.function_result.FunctionResult.with_response: to_json / to_value are serde serialization helpers; with_response is Rust's idiomatic alternative to Python's FunctionResult(response=...) constructor pattern.
signalwire.core.logging_config.parse_log_level: Rust-only public helper that parses a SIGNALWIRE_LOG_LEVEL string into the typed Level via the FromStr impl, returning the typed ParseLevelError on an unrecognized value. It is the validating entry point behind configure_logging (which now warns instead of silently defaulting on a bad level). Python's logging_config reads the level with getattr(logging, level.upper(), logging.INFO) — a silent fallback with no typed error, so there is no Python counterpart. Additive; wires the FromStr for Level error contract into a real cross-file use.
signalwire.core.security.session_manager.SessionManager.create_token: with_defaults is Rust's named-constructor for SessionManager::new() with the standard 3600s expiry; the others surface internal state / one-off helpers that the Python class hides as private.
signalwire.core.security.session_manager.SessionManager.token_expiry_secs: with_defaults is Rust's named-constructor for SessionManager::new() with the standard 3600s expiry; the others surface internal state / one-off helpers that the Python class hides as private.
signalwire.core.security.session_manager.SessionManager.with_defaults: with_defaults is Rust's named-constructor for SessionManager::new() with the standard 3600s expiry; the others surface internal state / one-off helpers that the Python class hides as private.
signalwire.core.security.session_manager.SessionManager.with_secret: Rust named constructor exposing an explicit signing secret; Python takes the equivalent via the secret_key kwarg of SessionManager.__init__ (which the Rust new intentionally omits — see PORT_SIGNATURE_OMISSIONS.md — so the escape hatch is a separate constructor).
signalwire.core.skill_base.SkillBase.description: Rust accessor for Python's SKILL_DESCRIPTION class attribute.
signalwire.core.skill_base.SkillBase.get_swaig_fields: Rust accessor for Python's self.swaig_fields instance attribute (extracted from params).
signalwire.core.skill_base.SkillBase.get_tool_name: Rust accessor that builds the instance-scoped tool name; Python computes the equivalent inline in define_tool.
signalwire.core.skill_base.SkillBase.name: Rust accessor for Python's SKILL_NAME class attribute.
signalwire.core.skill_base.SkillBase.params: Rust accessor for Python's self.params instance attribute.
signalwire.core.skill_base.SkillBase.required_env_vars: Rust accessor for the skill's required env-var list; Python exposes the equivalent via REQUIRED_ENV_VARS / validate_env_vars.
signalwire.core.skill_base.SkillBase.supports_multiple_instances: Rust accessor for Python's SUPPORTS_MULTIPLE_INSTANCES class attribute.
signalwire.core.skill_base.SkillBase.version: Rust accessor for Python's SKILL_VERSION class attribute.
signalwire.core.skill_manager.SkillManager.list_skills: Rust SkillManager exposes list_skills (mirrors Python's list_loaded_skills) and load_skill_instance (factory-driven instantiation, since Rust does not load .py files at runtime).
signalwire.core.skill_manager.SkillManager.load_skill_instance: Rust SkillManager exposes list_skills (mirrors Python's list_loaded_skills) and load_skill_instance (factory-driven instantiation, since Rust does not load .py files at runtime).
signalwire.core.swml_builder.Document: Rust's swml_builder ships a Document struct (Python uses dict shapes throughout). The methods are the build-side helpers a user would compose into a SWML doc.
signalwire.core.swml_builder.Document.init: Rust's swml_builder ships a Document struct (Python uses dict shapes throughout). The methods are the build-side helpers a user would compose into a SWML doc.
signalwire.core.swml_builder.Document.add_raw_verb: Rust's swml_builder ships a Document struct (Python uses dict shapes throughout). The methods are the build-side helpers a user would compose into a SWML doc.
signalwire.core.swml_builder.Document.add_section: Rust's swml_builder ships a Document struct (Python uses dict shapes throughout). The methods are the build-side helpers a user would compose into a SWML doc.
signalwire.core.swml_builder.Document.add_verb: Rust's swml_builder ships a Document struct (Python uses dict shapes throughout). The methods are the build-side helpers a user would compose into a SWML doc.
signalwire.core.swml_builder.Document.add_verb_to_section: Rust's swml_builder ships a Document struct (Python uses dict shapes throughout). The methods are the build-side helpers a user would compose into a SWML doc.
signalwire.core.swml_builder.Document.clear_section: Rust's swml_builder ships a Document struct (Python uses dict shapes throughout). The methods are the build-side helpers a user would compose into a SWML doc.
signalwire.core.swml_builder.Document.get_verbs: Rust's swml_builder ships a Document struct (Python uses dict shapes throughout). The methods are the build-side helpers a user would compose into a SWML doc.
signalwire.core.swml_builder.Document.has_section: Rust's swml_builder ships a Document struct (Python uses dict shapes throughout). The methods are the build-side helpers a user would compose into a SWML doc.
signalwire.core.swml_builder.Document.render: Rust's swml_builder ships a Document struct (Python uses dict shapes throughout). The methods are the build-side helpers a user would compose into a SWML doc.
signalwire.core.swml_builder.Document.render_pretty: Rust's swml_builder ships a Document struct (Python uses dict shapes throughout). The methods are the build-side helpers a user would compose into a SWML doc.
signalwire.core.swml_builder.Document.reset: Rust's swml_builder ships a Document struct (Python uses dict shapes throughout). The methods are the build-side helpers a user would compose into a SWML doc.
signalwire.core.swml_builder.Document.to_value: Rust's swml_builder ships a Document struct (Python uses dict shapes throughout). The methods are the build-side helpers a user would compose into a SWML doc.
signalwire.core.swml_builder.Document.version: Rust's swml_builder ships a Document struct (Python uses dict shapes throughout). The methods are the build-side helpers a user would compose into a SWML doc.
signalwire.core.swml_handler.VerbHandlerRegistry.handler_names: Rust accessor for the sorted verb-handler names; Python reads sorted(VerbHandlerRegistry._handlers.keys()) off the private dict.
signalwire.core.swml_service.SWMLService.basic_auth_credentials: These are Rust-idiomatic accessors / module helpers (basic_auth_credentials, document, document_mut, get_proxy_url_base, handle_request, has_tool, host, list_tool_names, name, on_function_call, port, register_swaig_function, render, render_pretty, route, run, sleep, tool_definition, define_tool). Python's SWMLService surface relies on dynamic attribute lookup and FastAPI router methods; Rust types them explicitly.
signalwire.core.swml_service.SWMLService.define_tool: These are Rust-idiomatic accessors / module helpers (basic_auth_credentials, document, document_mut, get_proxy_url_base, handle_request, has_tool, host, list_tool_names, name, on_function_call, port, register_swaig_function, render, render_pretty, route, run, sleep, tool_definition, define_tool). Python's SWMLService surface relies on dynamic attribute lookup and FastAPI router methods; Rust types them explicitly.
signalwire.core.swml_service.SWMLService.document: These are Rust-idiomatic accessors / module helpers (basic_auth_credentials, document, document_mut, get_proxy_url_base, handle_request, has_tool, host, list_tool_names, name, on_function_call, port, register_swaig_function, render, render_pretty, route, run, sleep, tool_definition, define_tool). Python's SWMLService surface relies on dynamic attribute lookup and FastAPI router methods; Rust types them explicitly.
signalwire.core.swml_service.SWMLService.document_mut: These are Rust-idiomatic accessors / module helpers (basic_auth_credentials, document, document_mut, get_proxy_url_base, handle_request, has_tool, host, list_tool_names, name, on_function_call, port, register_swaig_function, render, render_pretty, route, run, sleep, tool_definition, define_tool). Python's SWMLService surface relies on dynamic attribute lookup and FastAPI router methods; Rust types them explicitly.
signalwire.core.swml_service.SWMLService.get_all_functions: tool_mixin_lifted: Rust exposes the tool registry's accessors directly on SWMLService; Python keeps these on ToolRegistry (accessed via agent.tool_registry.get_all_functions()).
signalwire.core.swml_service.SWMLService.get_basic_auth_credentials_with_source: Rust variant of get_basic_auth_credentials that returns a 3-tuple (user, pass, source). Python uses the same method's include_source=True flag for this; Rust splits into two methods to keep the return type monomorphic.
signalwire.core.swml_service.SWMLService.get_function: tool_mixin_lifted: Rust exposes the tool registry's accessors directly on SWMLService; Python keeps these on ToolRegistry (mirrors tool_mixin_lifted pattern).
signalwire.core.swml_service.SWMLService.get_proxy_url_base: These are Rust-idiomatic accessors / module helpers (basic_auth_credentials, document, document_mut, get_proxy_url_base, handle_request, has_tool, host, list_tool_names, name, on_function_call, port, register_swaig_function, render, render_pretty, route, run, sleep, tool_definition, define_tool). Python's SWMLService surface relies on dynamic attribute lookup and FastAPI router methods; Rust types them explicitly.
signalwire.core.swml_service.SWMLService.has_function: tool_mixin_lifted: Rust exposes the tool registry's accessors directly on SWMLService; Python keeps these on ToolRegistry (mirrors tool_mixin_lifted pattern).
signalwire.core.swml_service.SWMLService.has_tool: These are Rust-idiomatic accessors / module helpers (basic_auth_credentials, document, document_mut, get_proxy_url_base, handle_request, has_tool, host, list_tool_names, name, on_function_call, port, register_swaig_function, render, render_pretty, route, run, sleep, tool_definition, define_tool). Python's SWMLService surface relies on dynamic attribute lookup and FastAPI router methods; Rust types them explicitly.
signalwire.core.swml_service.SWMLService.host: These are Rust-idiomatic accessors / module helpers (basic_auth_credentials, document, document_mut, get_proxy_url_base, handle_request, has_tool, host, list_tool_names, name, on_function_call, port, register_swaig_function, render, render_pretty, route, run, sleep, tool_definition, define_tool). Python's SWMLService surface relies on dynamic attribute lookup and FastAPI router methods; Rust types them explicitly.
signalwire.core.swml_service.SWMLService.list_tool_names: These are Rust-idiomatic accessors / module helpers (basic_auth_credentials, document, document_mut, get_proxy_url_base, handle_request, has_tool, host, list_tool_names, name, on_function_call, port, register_swaig_function, render, render_pretty, route, run, sleep, tool_definition, define_tool). Python's SWMLService surface relies on dynamic attribute lookup and FastAPI router methods; Rust types them explicitly.
signalwire.core.swml_service.SWMLService.name: These are Rust-idiomatic accessors / module helpers (basic_auth_credentials, document, document_mut, get_proxy_url_base, handle_request, has_tool, host, list_tool_names, name, on_function_call, port, register_swaig_function, render, render_pretty, route, run, sleep, tool_definition, define_tool). Python's SWMLService surface relies on dynamic attribute lookup and FastAPI router methods; Rust types them explicitly.
signalwire.core.swml_service.SWMLService.on_function_call: These are Rust-idiomatic accessors / module helpers (basic_auth_credentials, document, document_mut, get_proxy_url_base, handle_request, has_tool, host, list_tool_names, name, on_function_call, port, register_swaig_function, render, render_pretty, route, run, sleep, tool_definition, define_tool). Python's SWMLService surface relies on dynamic attribute lookup and FastAPI router methods; Rust types them explicitly.
signalwire.core.swml_service.SWMLService.on_swml_request: web_mixin_lifted: Rust rolls up WebMixin onto SWMLService so subclasses (notably AgentBase) can override the SWML-request hook directly; Python keeps on_swml_request on WebMixin (mirrors tool_mixin_lifted pattern).
signalwire.core.swml_service.SWMLService.port: These are Rust-idiomatic accessors / module helpers (basic_auth_credentials, document, document_mut, get_proxy_url_base, handle_request, has_tool, host, list_tool_names, name, on_function_call, port, register_swaig_function, render, render_pretty, route, run, sleep, tool_definition, define_tool). Python's SWMLService surface relies on dynamic attribute lookup and FastAPI router methods; Rust types them explicitly.
signalwire.core.swml_service.SWMLService.register_swaig_function: These are Rust-idiomatic accessors / module helpers (basic_auth_credentials, document, document_mut, get_proxy_url_base, handle_request, has_tool, host, list_tool_names, name, on_function_call, port, register_swaig_function, render, render_pretty, route, run, sleep, tool_definition, define_tool). Python's SWMLService surface relies on dynamic attribute lookup and FastAPI router methods; Rust types them explicitly.
signalwire.core.swml_service.SWMLService.remove_function: tool_mixin_lifted: Rust exposes the tool registry's mutators directly on SWMLService; Python keeps these on ToolRegistry (mirrors tool_mixin_lifted pattern).
signalwire.core.swml_service.SWMLService.render: These are Rust-idiomatic accessors / module helpers (basic_auth_credentials, document, document_mut, get_proxy_url_base, handle_request, has_tool, host, list_tool_names, name, on_function_call, port, register_swaig_function, render, render_pretty, route, run, sleep, tool_definition, define_tool). Python's SWMLService surface relies on dynamic attribute lookup and FastAPI router methods; Rust types them explicitly.
signalwire.core.swml_service.SWMLService.render_pretty: These are Rust-idiomatic accessors / module helpers (basic_auth_credentials, document, document_mut, get_proxy_url_base, handle_request, has_tool, host, list_tool_names, name, on_function_call, port, register_swaig_function, render, render_pretty, route, run, sleep, tool_definition, define_tool). Python's SWMLService surface relies on dynamic attribute lookup and FastAPI router methods; Rust types them explicitly.
signalwire.core.swml_service.SWMLService.route: These are Rust-idiomatic accessors / module helpers (basic_auth_credentials, document, document_mut, get_proxy_url_base, handle_request, has_tool, host, list_tool_names, name, on_function_call, port, register_swaig_function, render, render_pretty, route, run, sleep, tool_definition, define_tool). Python's SWMLService surface relies on dynamic attribute lookup and FastAPI router methods; Rust types them explicitly.
signalwire.core.swml_service.SWMLService.routing_callback_paths: Rust accessor for the sorted normalized routing-callback paths; Python reads sorted(SWMLService._routing_callbacks.keys()) off the private dict.
signalwire.core.swml_service.SWMLService.run: These are Rust-idiomatic accessors / module helpers (basic_auth_credentials, document, document_mut, get_proxy_url_base, handle_request, has_tool, host, list_tool_names, name, on_function_call, port, register_swaig_function, render, render_pretty, route, run, sleep, tool_definition, define_tool). Python's SWMLService surface relies on dynamic attribute lookup and FastAPI router methods; Rust types them explicitly.
signalwire.core.swml_service.SWMLService.set_on_swml_request_hook: Rust function-field hook setter used in place of subclass override; Python's WebMixin.on_swml_request is overridden via subclassing, but Rust has no method inheritance so the hook is registered as a closure on Service.
signalwire.core.swml_service.SWMLService.sleep: These are Rust-idiomatic accessors / module helpers (basic_auth_credentials, document, document_mut, get_proxy_url_base, handle_request, has_tool, host, list_tool_names, name, on_function_call, port, register_swaig_function, render, render_pretty, route, run, sleep, tool_definition, define_tool). Python's SWMLService surface relies on dynamic attribute lookup and FastAPI router methods; Rust types them explicitly.
signalwire.core.swml_service.SWMLService.tool_definition: These are Rust-idiomatic accessors / module helpers (basic_auth_credentials, document, document_mut, get_proxy_url_base, handle_request, has_tool, host, list_tool_names, name, on_function_call, port, register_swaig_function, render, render_pretty, route, run, sleep, tool_definition, define_tool). Python's SWMLService surface relies on dynamic attribute lookup and FastAPI router methods; Rust types them explicitly.
signalwire.core.swml_service.SWMLService.validate_basic_auth: auth_mixin_lifted: Rust rolls up AuthMixin onto SWMLService; Python keeps validate_basic_auth on AuthMixin and accesses it via the mixin chain (mirrors tool_mixin_lifted pattern).
signalwire.logging.Level: Rust ships an explicit Logger type and Level enum with associated helpers. Python uses the standard logging module with helper wrappers in signalwire.core.logging_config (which is in PORT_OMISSIONS.md).
signalwire.logging.Level.all: rust_enum_idiom: &'static slice of every Level (debug/info/warn/error) in ascending-severity order for exhaustive iteration. Python uses the stdlib logging module; this is the Rust enum's closed-set helper.
signalwire.logging.Level.as_str: Rust ships an explicit Logger type and Level enum with associated helpers. Python uses the standard logging module with helper wrappers in signalwire.core.logging_config (which is in PORT_OMISSIONS.md).
signalwire.logging.Level.from_str: Rust ships an explicit Logger type and Level enum with associated helpers. Python uses the standard logging module with helper wrappers in signalwire.core.logging_config (which is in PORT_OMISSIONS.md).
signalwire.logging.Logger: Rust ships an explicit Logger type and Level enum with associated helpers. Python uses the standard logging module with helper wrappers in signalwire.core.logging_config (which is in PORT_OMISSIONS.md).
signalwire.logging.Logger.init: Rust ships an explicit Logger type and Level enum with associated helpers. Python uses the standard logging module with helper wrappers in signalwire.core.logging_config (which is in PORT_OMISSIONS.md).
signalwire.logging.Logger.debug: Rust ships an explicit Logger type and Level enum with associated helpers. Python uses the standard logging module with helper wrappers in signalwire.core.logging_config (which is in PORT_OMISSIONS.md).
signalwire.logging.Logger.error: Rust ships an explicit Logger type and Level enum with associated helpers. Python uses the standard logging module with helper wrappers in signalwire.core.logging_config (which is in PORT_OMISSIONS.md).
signalwire.logging.Logger.info: Rust ships an explicit Logger type and Level enum with associated helpers. Python uses the standard logging module with helper wrappers in signalwire.core.logging_config (which is in PORT_OMISSIONS.md).
signalwire.logging.Logger.log: Rust ships an explicit Logger type and Level enum with associated helpers. Python uses the standard logging module with helper wrappers in signalwire.core.logging_config (which is in PORT_OMISSIONS.md).
signalwire.logging.Logger.should_log: Rust ships an explicit Logger type and Level enum with associated helpers. Python uses the standard logging module with helper wrappers in signalwire.core.logging_config (which is in PORT_OMISSIONS.md).
signalwire.logging.Logger.warn: Rust ships an explicit Logger type and Level enum with associated helpers. Python uses the standard logging module with helper wrappers in signalwire.core.logging_config (which is in PORT_OMISSIONS.md).
signalwire.logging.ParseLevelError: rust-parse-error — FromStr::Err for the log Level enum ("debug".parse::<Level>()), case-insensitive. No Python equivalent.
signalwire.logging.ParseLevelError.input: rust-error-accessor — returns the string that was not a valid log level. No Python equivalent.
signalwire.logging.init: Rust ships an explicit Logger type and Level enum with associated helpers. Python uses the standard logging module with helper wrappers in signalwire.core.logging_config (which is in PORT_OMISSIONS.md).
signalwire.prefabs.concierge.ConciergeAgent.agent: Rust prefabs (InfoGathererAgent, SurveyAgent, ReceptionistAgent, FAQBotAgent, ConciergeAgent) wrap an AgentBase via composition + Deref. The agent / agent_mut accessors expose the wrapped AgentBase explicitly. Python prefabs subclass AgentBase so attribute access is direct.
signalwire.prefabs.concierge.ConciergeAgent.agent_mut: Rust prefabs (InfoGathererAgent, SurveyAgent, ReceptionistAgent, FAQBotAgent, ConciergeAgent) wrap an AgentBase via composition + Deref. The agent / agent_mut accessors expose the wrapped AgentBase explicitly. Python prefabs subclass AgentBase so attribute access is direct.
signalwire.prefabs.concierge.ConciergeAgent.amenities: Rust prefabs (InfoGathererAgent, SurveyAgent, ReceptionistAgent, FAQBotAgent, ConciergeAgent) wrap an AgentBase via composition + Deref. The agent / agent_mut accessors expose the wrapped AgentBase explicitly. Python prefabs subclass AgentBase so attribute access is direct.
signalwire.prefabs.concierge.ConciergeAgent.services: Rust prefabs (InfoGathererAgent, SurveyAgent, ReceptionistAgent, FAQBotAgent, ConciergeAgent) wrap an AgentBase via composition + Deref. The agent / agent_mut accessors expose the wrapped AgentBase explicitly. Python prefabs subclass AgentBase so attribute access is direct.
signalwire.prefabs.concierge.ConciergeAgent.venue_name: Rust prefabs (InfoGathererAgent, SurveyAgent, ReceptionistAgent, FAQBotAgent, ConciergeAgent) wrap an AgentBase via composition + Deref. The agent / agent_mut accessors expose the wrapped AgentBase explicitly. Python prefabs subclass AgentBase so attribute access is direct.
signalwire.prefabs.faq_bot.FAQBotAgent.agent: Rust prefabs (InfoGathererAgent, SurveyAgent, ReceptionistAgent, FAQBotAgent, ConciergeAgent) wrap an AgentBase via composition + Deref. The agent / agent_mut accessors expose the wrapped AgentBase explicitly. Python prefabs subclass AgentBase so attribute access is direct.
signalwire.prefabs.faq_bot.FAQBotAgent.agent_mut: Rust prefabs (InfoGathererAgent, SurveyAgent, ReceptionistAgent, FAQBotAgent, ConciergeAgent) wrap an AgentBase via composition + Deref. The agent / agent_mut accessors expose the wrapped AgentBase explicitly. Python prefabs subclass AgentBase so attribute access is direct.
signalwire.prefabs.faq_bot.FAQBotAgent.faqs: Rust prefabs (InfoGathererAgent, SurveyAgent, ReceptionistAgent, FAQBotAgent, ConciergeAgent) wrap an AgentBase via composition + Deref. The agent / agent_mut accessors expose the wrapped AgentBase explicitly. Python prefabs subclass AgentBase so attribute access is direct.
signalwire.prefabs.faq_bot.FAQBotAgent.suggest_related: Rust prefabs (InfoGathererAgent, SurveyAgent, ReceptionistAgent, FAQBotAgent, ConciergeAgent) wrap an AgentBase via composition + Deref. The agent / agent_mut accessors expose the wrapped AgentBase explicitly. Python prefabs subclass AgentBase so attribute access is direct.
signalwire.prefabs.info_gatherer.InfoGathererAgent.agent: Rust prefabs (InfoGathererAgent, SurveyAgent, ReceptionistAgent, FAQBotAgent, ConciergeAgent) wrap an AgentBase via composition + Deref. The agent / agent_mut accessors expose the wrapped AgentBase explicitly. Python prefabs subclass AgentBase so attribute access is direct.
signalwire.prefabs.info_gatherer.InfoGathererAgent.agent_mut: Rust prefabs (InfoGathererAgent, SurveyAgent, ReceptionistAgent, FAQBotAgent, ConciergeAgent) wrap an AgentBase via composition + Deref. The agent / agent_mut accessors expose the wrapped AgentBase explicitly. Python prefabs subclass AgentBase so attribute access is direct.
signalwire.prefabs.info_gatherer.InfoGathererAgent.questions: Rust prefabs (InfoGathererAgent, SurveyAgent, ReceptionistAgent, FAQBotAgent, ConciergeAgent) wrap an AgentBase via composition + Deref. The agent / agent_mut accessors expose the wrapped AgentBase explicitly. Python prefabs subclass AgentBase so attribute access is direct.
signalwire.prefabs.receptionist.ReceptionistAgent.agent: Rust prefabs (InfoGathererAgent, SurveyAgent, ReceptionistAgent, FAQBotAgent, ConciergeAgent) wrap an AgentBase via composition + Deref. The agent / agent_mut accessors expose the wrapped AgentBase explicitly. Python prefabs subclass AgentBase so attribute access is direct.
signalwire.prefabs.receptionist.ReceptionistAgent.agent_mut: Rust prefabs (InfoGathererAgent, SurveyAgent, ReceptionistAgent, FAQBotAgent, ConciergeAgent) wrap an AgentBase via composition + Deref. The agent / agent_mut accessors expose the wrapped AgentBase explicitly. Python prefabs subclass AgentBase so attribute access is direct.
signalwire.prefabs.receptionist.ReceptionistAgent.departments: Rust prefabs (InfoGathererAgent, SurveyAgent, ReceptionistAgent, FAQBotAgent, ConciergeAgent) wrap an AgentBase via composition + Deref. The agent / agent_mut accessors expose the wrapped AgentBase explicitly. Python prefabs subclass AgentBase so attribute access is direct.
signalwire.prefabs.receptionist.ReceptionistAgent.greeting: Rust prefabs (InfoGathererAgent, SurveyAgent, ReceptionistAgent, FAQBotAgent, ConciergeAgent) wrap an AgentBase via composition + Deref. The agent / agent_mut accessors expose the wrapped AgentBase explicitly. Python prefabs subclass AgentBase so attribute access is direct.
signalwire.prefabs.survey.SurveyAgent.agent: Rust prefabs (InfoGathererAgent, SurveyAgent, ReceptionistAgent, FAQBotAgent, ConciergeAgent) wrap an AgentBase via composition + Deref. The agent / agent_mut accessors expose the wrapped AgentBase explicitly. Python prefabs subclass AgentBase so attribute access is direct.
signalwire.prefabs.survey.SurveyAgent.agent_mut: Rust prefabs (InfoGathererAgent, SurveyAgent, ReceptionistAgent, FAQBotAgent, ConciergeAgent) wrap an AgentBase via composition + Deref. The agent / agent_mut accessors expose the wrapped AgentBase explicitly. Python prefabs subclass AgentBase so attribute access is direct.
signalwire.prefabs.survey.SurveyAgent.survey_name: Rust prefabs (InfoGathererAgent, SurveyAgent, ReceptionistAgent, FAQBotAgent, ConciergeAgent) wrap an AgentBase via composition + Deref. The agent / agent_mut accessors expose the wrapped AgentBase explicitly. Python prefabs subclass AgentBase so attribute access is direct.
signalwire.relay.action.init: Rust action.rs file-private helpers; module-level identifiers that don't have a Python equivalent.
signalwire.relay.action.action: Rust action.rs file-private helpers; module-level identifiers that don't have a Python equivalent.
signalwire.relay.call.AIAction.action: Rust Action subclasses expose an action() accessor that returns the underlying Action struct (the inner state shared across all action variants). Python uses inheritance, so this accessor does not exist as a method.
signalwire.relay.call.Action.call_id: Rust models all Action variants (PlayAction, RecordAction, …) on top of a single Action struct that exposes shared accessors (call_id, control_id, state, …). Python uses an action-class-per-type hierarchy; the same data is exposed via attribute access on each action.
signalwire.relay.call.Action.control_id: Rust models all Action variants (PlayAction, RecordAction, …) on top of a single Action struct that exposes shared accessors (call_id, control_id, state, …). Python uses an action-class-per-type hierarchy; the same data is exposed via attribute access on each action.
signalwire.relay.call.Action.events: Rust models all Action variants (PlayAction, RecordAction, …) on top of a single Action struct that exposes shared accessors (call_id, control_id, state, …). Python uses an action-class-per-type hierarchy; the same data is exposed via attribute access on each action.
signalwire.relay.call.Action.execute_subcommand: Rust models all Action variants (PlayAction, RecordAction, …) on top of a single Action struct that exposes shared accessors (call_id, control_id, state, …). Python uses an action-class-per-type hierarchy; the same data is exposed via attribute access on each action.
signalwire.relay.call.Action.handle_event: Rust models all Action variants (PlayAction, RecordAction, …) on top of a single Action struct that exposes shared accessors (call_id, control_id, state, …). Python uses an action-class-per-type hierarchy; the same data is exposed via attribute access on each action.
signalwire.relay.call.Action.node_id: Rust models all Action variants (PlayAction, RecordAction, …) on top of a single Action struct that exposes shared accessors (call_id, control_id, state, …). Python uses an action-class-per-type hierarchy; the same data is exposed via attribute access on each action.
signalwire.relay.call.Action.on_completed: Rust models all Action variants (PlayAction, RecordAction, …) on top of a single Action struct that exposes shared accessors (call_id, control_id, state, …). Python uses an action-class-per-type hierarchy; the same data is exposed via attribute access on each action.
signalwire.relay.call.Action.payload: Rust models all Action variants (PlayAction, RecordAction, …) on top of a single Action struct that exposes shared accessors (call_id, control_id, state, …). Python uses an action-class-per-type hierarchy; the same data is exposed via attribute access on each action.
signalwire.relay.call.Action.resolve: Rust models all Action variants (PlayAction, RecordAction, …) on top of a single Action struct that exposes shared accessors (call_id, control_id, state, …). Python uses an action-class-per-type hierarchy; the same data is exposed via attribute access on each action.
signalwire.relay.call.Action.sent_commands: Rust read accessor for the in-memory sub-command frames an Action has emitted (wire-frame introspection); Python inspects the equivalent via its recording test stub.
signalwire.relay.call.Action.set_client: Port-only wiring setter. Python's Action reaches the wire through self.call._execute (it holds a Call reference passed at construction). Rust's Action is built from plain IDs (control_id/call_id/node_id) and is attached to the owning Client by Call::start_action via this setter, so its control-op sub-commands (stop/pause/resume/volume) transmit through Client::send_request. No Python counterpart — Python injects the client transitively at construction; Rust wires it explicitly to avoid an Arc reference cycle.
signalwire.relay.call.Action.set_notify_sender: Rust models all Action variants (PlayAction, RecordAction, …) on top of a single Action struct that exposes shared accessors (call_id, control_id, state, …). Python uses an action-class-per-type hierarchy; the same data is exposed via attribute access on each action.
signalwire.relay.call.Action.state: Rust models all Action variants (PlayAction, RecordAction, …) on top of a single Action struct that exposes shared accessors (call_id, control_id, state, …). Python uses an action-class-per-type hierarchy; the same data is exposed via attribute access on each action.
signalwire.relay.call.Action.stop: Rust models all Action variants (PlayAction, RecordAction, …) on top of a single Action struct that exposes shared accessors (call_id, control_id, state, …). Python uses an action-class-per-type hierarchy; the same data is exposed via attribute access on each action.
signalwire.relay.call.Action.stop_method: Rust models all Action variants (PlayAction, RecordAction, …) on top of a single Action struct that exposes shared accessors (call_id, control_id, state, …). Python uses an action-class-per-type hierarchy; the same data is exposed via attribute access on each action.
signalwire.relay.call.Action.with_stop_method: Rust models all Action variants (PlayAction, RecordAction, …) on top of a single Action struct that exposes shared accessors (call_id, control_id, state, …). Python uses an action-class-per-type hierarchy; the same data is exposed via attribute access on each action.
signalwire.relay.call.Call.call_state: Typed Tier-3 accessor returning the call state as a CallState enum (created/ringing/answered/ending/ended, #[non_exhaustive] with Other for unknown server values), exposed ALONGSIDE the string current_state() for parity — call_state().as_str() == current_state() always. Python's dynamic state attribute is a bare string; this is the floor-not-ceiling typed view. Additive; no Python equivalent.
signalwire.relay.call.Call.current_state: current_state mirrors Python's state attribute under a method name. dispatch_event is the public event-router (private in Python). echo_call / refer_call / pass replace Python's reserved-word-clashing Call.echo / Call.refer / Call.pass_. resolve_all_actions is a Rust convenience for terminal cleanup.
signalwire.relay.call.Call.dispatch_event: current_state mirrors Python's state attribute under a method name. dispatch_event is the public event-router (private in Python). echo_call / refer_call / pass replace Python's reserved-word-clashing Call.echo / Call.refer / Call.pass_. resolve_all_actions is a Rust convenience for terminal cleanup.
signalwire.relay.call.Call.echo_call: current_state mirrors Python's state attribute under a method name. dispatch_event is the public event-router (private in Python). echo_call / refer_call / pass replace Python's reserved-word-clashing Call.echo / Call.refer / Call.pass_. resolve_all_actions is a Rust convenience for terminal cleanup.
signalwire.relay.call.Call.pass: current_state mirrors Python's state attribute under a method name. dispatch_event is the public event-router (private in Python). echo_call / refer_call / pass replace Python's reserved-word-clashing Call.echo / Call.refer / Call.pass_. resolve_all_actions is a Rust convenience for terminal cleanup.
signalwire.relay.call.Call.refer_call: current_state mirrors Python's state attribute under a method name. dispatch_event is the public event-router (private in Python). echo_call / refer_call / pass replace Python's reserved-word-clashing Call.echo / Call.refer / Call.pass_. resolve_all_actions is a Rust convenience for terminal cleanup.
signalwire.relay.call.Call.resolve_all_actions: current_state mirrors Python's state attribute under a method name. dispatch_event is the public event-router (private in Python). echo_call / refer_call / pass replace Python's reserved-word-clashing Call.echo / Call.refer / Call.pass_. resolve_all_actions is a Rust convenience for terminal cleanup.
signalwire.relay.call.Call.sent_commands: Rust read accessor returning a bounded snapshot of the (method, params) frames a Call has built (wire-frame introspection / tests); Python inspects the equivalent via its recording test stub. Backing field is pub(crate) (not caller-mutable) and capped at crate::relay::SENT_LOG_CAP so a long-running call can't leak memory. Mirrors the existing Action.sent_commands accessor.
signalwire.relay.call.Call.set_client: Port-only wiring setter with no Python counterpart. Python's Call.__init__ receives the RelayClient as a constructor argument and every verb transmits via self._client.execute. Rust's Client OWNS its Calls (Mutex<HashMap<String, Arc<Call>>>), so it constructs the Call first (from a server event payload) and then attaches itself through this setter; the Call stores a Weak<Client> to avoid an Arc reference cycle. Once attached, Call::execute / start_action transmit the built frame through Client::send_request — the client-send boundary. This is the fix for the RELAY non-transmission bug (a Call whose verbs only recorded into sent_commands and never reached the wire).
signalwire.relay.call.CollectAction.action: Specific accessors on the per-action Rust subtypes (CollectAction.collect_result, DetectAction.detect_result, FaxAction.action / fax_type, RecordAction.duration / size / url). Python exposes the same data via attribute access.
signalwire.relay.call.CollectAction.collect_result: Specific accessors on the per-action Rust subtypes (CollectAction.collect_result, DetectAction.detect_result, FaxAction.action / fax_type, RecordAction.duration / size / url). Python exposes the same data via attribute access.
signalwire.relay.call.CollectAction.handle_event_filtered: Specific accessors on the per-action Rust subtypes (CollectAction.collect_result, DetectAction.detect_result, FaxAction.action / fax_type, RecordAction.duration / size / url). Python exposes the same data via attribute access.
signalwire.relay.call.DetectAction.action: Rust Action subclasses expose an action() accessor that returns the underlying Action struct (the inner state shared across all action variants). Python uses inheritance, so this accessor does not exist as a method.
signalwire.relay.call.DetectAction.detect_result: Specific accessors on the per-action Rust subtypes (CollectAction.collect_result, DetectAction.detect_result, FaxAction.action / fax_type, RecordAction.duration / size / url). Python exposes the same data via attribute access.
signalwire.relay.call.FaxAction.action: Specific accessors on the per-action Rust subtypes (CollectAction.collect_result, DetectAction.detect_result, FaxAction.action / fax_type, RecordAction.duration / size / url). Python exposes the same data via attribute access.
signalwire.relay.call.FaxAction.fax_type: Specific accessors on the per-action Rust subtypes (CollectAction.collect_result, DetectAction.detect_result, FaxAction.action / fax_type, RecordAction.duration / size / url). Python exposes the same data via attribute access.
signalwire.relay.call.PayAction.action: Rust Action subclasses expose an action() accessor that returns the underlying Action struct (the inner state shared across all action variants). Python uses inheritance, so this accessor does not exist as a method.
signalwire.relay.call.PlayAction.action: Rust Action subclasses expose an action() accessor that returns the underlying Action struct (the inner state shared across all action variants). Python uses inheritance, so this accessor does not exist as a method.
signalwire.relay.call.RecordAction.action: Rust Action subclasses expose an action() accessor that returns the underlying Action struct (the inner state shared across all action variants). Python uses inheritance, so this accessor does not exist as a method.
signalwire.relay.call.RecordAction.duration: Specific accessors on the per-action Rust subtypes (CollectAction.collect_result, DetectAction.detect_result, FaxAction.action / fax_type, RecordAction.duration / size / url). Python exposes the same data via attribute access.
signalwire.relay.call.RecordAction.size: Specific accessors on the per-action Rust subtypes (CollectAction.collect_result, DetectAction.detect_result, FaxAction.action / fax_type, RecordAction.duration / size / url). Python exposes the same data via attribute access.
signalwire.relay.call.RecordAction.url: Specific accessors on the per-action Rust subtypes (CollectAction.collect_result, DetectAction.detect_result, FaxAction.action / fax_type, RecordAction.duration / size / url). Python exposes the same data via attribute access.
signalwire.relay.call.StreamAction.action: Rust Action subclasses expose an action() accessor that returns the underlying Action struct (the inner state shared across all action variants). Python uses inheritance, so this accessor does not exist as a method.
signalwire.relay.call.TapAction.action: Rust Action subclasses expose an action() accessor that returns the underlying Action struct (the inner state shared across all action variants). Python uses inheritance, so this accessor does not exist as a method.
signalwire.relay.call.TranscribeAction.action: Rust Action subclasses expose an action() accessor that returns the underlying Action struct (the inner state shared across all action variants). Python uses inheritance, so this accessor does not exist as a method.
signalwire.relay.client.RelayClient.authenticate: Rust splits the RelayClient surface into explicit methods (authenticate, send_request, …) where Python uses dynamic dispatch (RelayClient.execute, send_message). These are the equivalent typed methods.
signalwire.relay.client.RelayClient.authenticate_blocking: Rust splits the RelayClient surface into explicit methods (authenticate, send_request, …) where Python uses dynamic dispatch (RelayClient.execute, send_message). These are the equivalent typed methods.
signalwire.relay.client.RelayClient.bump_reconnect_delay: Rust splits the RelayClient surface into explicit methods (authenticate, send_request, …) where Python uses dynamic dispatch (RelayClient.execute, send_message). These are the equivalent typed methods.
signalwire.relay.client.RelayClient.connect_fresh: Rust splits the RelayClient surface into explicit methods (authenticate, send_request, …) where Python uses dynamic dispatch (RelayClient.execute, send_message). These are the equivalent typed methods.
signalwire.relay.client.RelayClient.dial_blocking: Rust ships blocking-IO variants of the async dial/execute/send_message methods so synchronous Rust code can invoke RELAY without spinning up a tokio runtime. Python's RelayClient is async-only.
signalwire.relay.client.RelayClient.execute_blocking: Rust ships blocking-IO variants of the async dial/execute/send_message methods so synchronous Rust code can invoke RELAY without spinning up a tokio runtime. Python's RelayClient is async-only.
signalwire.relay.client.RelayClient.from_env: Rust splits the RelayClient surface into explicit methods (authenticate, send_request, …) where Python uses dynamic dispatch (RelayClient.execute, send_message). These are the equivalent typed methods.
signalwire.relay.client.RelayClient.get_call: Rust splits the RelayClient surface into explicit methods (authenticate, send_request, …) where Python uses dynamic dispatch (RelayClient.execute, send_message). These are the equivalent typed methods.
signalwire.relay.client.RelayClient.get_message: Rust splits the RelayClient surface into explicit methods (authenticate, send_request, …) where Python uses dynamic dispatch (RelayClient.execute, send_message). These are the equivalent typed methods.
signalwire.relay.client.RelayClient.handle_event: Rust splits the RelayClient surface into explicit methods (authenticate, send_request, …) where Python uses dynamic dispatch (RelayClient.execute, send_message). These are the equivalent typed methods.
signalwire.relay.client.RelayClient.handle_message: Rust splits the RelayClient surface into explicit methods (authenticate, send_request, …) where Python uses dynamic dispatch (RelayClient.execute, send_message). These are the equivalent typed methods.
signalwire.relay.client.RelayClient.is_connected: Rust splits the RelayClient surface into explicit methods (authenticate, send_request, …) where Python uses dynamic dispatch (RelayClient.execute, send_message). These are the equivalent typed methods.
signalwire.relay.client.RelayClient.is_running: Rust splits the RelayClient surface into explicit methods (authenticate, send_request, …) where Python uses dynamic dispatch (RelayClient.execute, send_message). These are the equivalent typed methods.
signalwire.relay.client.RelayClient.on_event: Rust splits the RelayClient surface into explicit methods (authenticate, send_request, …) where Python uses dynamic dispatch (RelayClient.execute, send_message). These are the equivalent typed methods.
signalwire.relay.client.RelayClient.reconnect: Rust splits the RelayClient surface into explicit methods (authenticate, send_request, …) where Python uses dynamic dispatch (RelayClient.execute, send_message). These are the equivalent typed methods.
signalwire.relay.client.RelayClient.register_dial: Rust splits the RelayClient surface into explicit methods (authenticate, send_request, …) where Python uses dynamic dispatch (RelayClient.execute, send_message). These are the equivalent typed methods.
signalwire.relay.client.RelayClient.register_pending: Rust splits the RelayClient surface into explicit methods (authenticate, send_request, …) where Python uses dynamic dispatch (RelayClient.execute, send_message). These are the equivalent typed methods.
signalwire.relay.client.RelayClient.remove_pending_dial: Rust splits the RelayClient surface into explicit methods (authenticate, send_request, …) where Python uses dynamic dispatch (RelayClient.execute, send_message). These are the equivalent typed methods.
signalwire.relay.client.RelayClient.send: Rust splits the RelayClient surface into explicit methods (authenticate, send_request, …) where Python uses dynamic dispatch (RelayClient.execute, send_message). These are the equivalent typed methods.
signalwire.relay.client.RelayClient.send_ack: Rust splits the RelayClient surface into explicit methods (authenticate, send_request, …) where Python uses dynamic dispatch (RelayClient.execute, send_message). These are the equivalent typed methods.
signalwire.relay.client.RelayClient.send_message_blocking: Rust ships blocking-IO variants of the async dial/execute/send_message methods so synchronous Rust code can invoke RELAY without spinning up a tokio runtime. Python's RelayClient is async-only.
signalwire.relay.client.RelayClient.send_request: Rust splits the RelayClient surface into explicit methods (authenticate, send_request, …) where Python uses dynamic dispatch (RelayClient.execute, send_message). These are the equivalent typed methods.
signalwire.relay.client.RelayClient.sent_messages: Rust read accessor returning a bounded snapshot of the frames the client has sent through the transport (wire-frame introspection / tests); Python inspects the equivalent via its recording test stub. Backing field is pub(crate) (not caller-mutable) and capped at crate::relay::SENT_LOG_CAP so a long-running session can't leak memory. Mirrors the Call.sent_commands / Action.sent_commands accessors.
signalwire.relay.client.RelayClient.track_message: Rust splits the RelayClient surface into explicit methods (authenticate, send_request, …) where Python uses dynamic dispatch (RelayClient.execute, send_message). These are the equivalent typed methods.
signalwire.relay.client.ws_connect: rust-transport-helper — opens a verified WebSocket (plain ws:// or rustls wss://, optionally trusting a private CA) for the relay client. Python's websocket connect is internal to RelayClient.
signalwire.relay.constants.is_action_terminal: Rust ships free functions in relay::constants for terminal-state checks. Python exposes the same predicates as static methods on the Action/Call/Message classes.
signalwire.relay.constants.is_call_terminal: Rust ships free functions in relay::constants for terminal-state checks. Python exposes the same predicates as static methods on the Action/Call/Message classes.
signalwire.relay.constants.is_message_terminal: Rust ships free functions in relay::constants for terminal-state checks. Python exposes the same predicates as static methods on the Action/Call/Message classes.
signalwire.relay.device.Device: Typed RELAY device descriptor (device_type: String + params: Value); types the wire shape only. See section preamble.
signalwire.relay.device.Device.init: Device::new(type, params) constructor; non-object params normalise to {} on the wire. See section preamble.
signalwire.relay.device.Device.matrix: Build the serial/parallel device matrix ([[device,…],…]) that dial/connect take, from rows of Devices. See section preamble.
signalwire.relay.device.Device.phone: Convenience constructor for a phone device ({to_number, from_number}). See section preamble.
signalwire.relay.device.Device.sip: Convenience constructor for a sip device ({to, from}). See section preamble.
signalwire.relay.device.Device.to_value: Serialise to the wire device object {"type":…,"params":{…}}, byte-identical to the hand-written form. See section preamble.
signalwire.relay.client.RelayError.missing_env: rust-error-ctor — convenience constructor for the MissingEnv variant naming the unset variable. No Python equivalent.
signalwire.relay.client.RelayError.transport: rust-error-ctor — convenience constructor for the Transport variant from a context + any Display cause; used by the client's map_err sites. No Python equivalent.
signalwire.relay.event.CallStateEvent.call_id: Rust accessor for the call_id field; Python CallStateEvent.call_id dataclass field.
signalwire.relay.event.CallStateEvent.call_state: Rust accessor for the call_state field; Python CallStateEvent.call_state dataclass field.
signalwire.relay.event.CallStateEvent.direction: Rust accessor for the direction field; Python CallStateEvent.direction dataclass field.
signalwire.relay.event.CollectEvent.control_id: Rust accessor for the control_id field; Python CollectEvent.control_id dataclass field.
signalwire.relay.event.CollectEvent.result: Rust accessor for the result object; Python CollectEvent.result dataclass field.
signalwire.relay.event.CollectEvent.state: Rust accessor for the state field; Python CollectEvent.state dataclass field.
signalwire.relay.event.Event: Rust-idiomatic API; no direct Python equivalent in the auto-generated python_surface.json.
signalwire.relay.event.Event.init: Rust models Event as a struct with typed accessors (call_id, control_id, event_type, …) and helpers (parse, to_value). Python uses an Event class hierarchy with attribute access — the data is the same; the accessor names differ.
signalwire.relay.event.Event.call_id: Rust models Event as a struct with typed accessors (call_id, control_id, event_type, …) and helpers (parse, to_value). Python uses an Event class hierarchy with attribute access — the data is the same; the accessor names differ.
signalwire.relay.event.Event.control_id: Rust models Event as a struct with typed accessors (call_id, control_id, event_type, …) and helpers (parse, to_value). Python uses an Event class hierarchy with attribute access — the data is the same; the accessor names differ.
signalwire.relay.event.Event.node_id: Rust models Event as a struct with typed accessors (call_id, control_id, event_type, …) and helpers (parse, to_value). Python uses an Event class hierarchy with attribute access — the data is the same; the accessor names differ.
signalwire.relay.event.Event.params: Rust models Event as a struct with typed accessors (call_id, control_id, event_type, …) and helpers (parse, to_value). Python uses an Event class hierarchy with attribute access — the data is the same; the accessor names differ.
signalwire.relay.event.Event.parse: Rust models Event as a struct with typed accessors (call_id, control_id, event_type, …) and helpers (parse, to_value). Python uses an Event class hierarchy with attribute access — the data is the same; the accessor names differ.
signalwire.relay.event.Event.state: Rust models Event as a struct with typed accessors (call_id, control_id, event_type, …) and helpers (parse, to_value). Python uses an Event class hierarchy with attribute access — the data is the same; the accessor names differ.
signalwire.relay.event.Event.tag: Rust models Event as a struct with typed accessors (call_id, control_id, event_type, …) and helpers (parse, to_value). Python uses an Event class hierarchy with attribute access — the data is the same; the accessor names differ.
signalwire.relay.event.Event.timestamp: Rust models Event as a struct with typed accessors (call_id, control_id, event_type, …) and helpers (parse, to_value). Python uses an Event class hierarchy with attribute access — the data is the same; the accessor names differ.
signalwire.relay.event.Event.to_value: Rust models Event as a struct with typed accessors (call_id, control_id, event_type, …) and helpers (parse, to_value). Python uses an Event class hierarchy with attribute access — the data is the same; the accessor names differ.
signalwire.relay.event.QueueEvent.control_id: Rust accessor for the control_id field; Python QueueEvent.control_id dataclass field.
signalwire.relay.event.QueueEvent.position: Rust accessor for the position field; Python QueueEvent.position dataclass field.
signalwire.relay.event.QueueEvent.queue_id: Rust accessor for the queue_id field (renamed from wire id); Python QueueEvent.queue_id dataclass field.
signalwire.relay.event.QueueEvent.queue_name: Rust accessor for the queue_name field (renamed from wire name); Python QueueEvent.queue_name dataclass field.
signalwire.relay.event.QueueEvent.size: Rust accessor for the size field; Python QueueEvent.size dataclass field.
signalwire.relay.event.QueueEvent.status: Rust accessor for the status field; Python QueueEvent.status dataclass field.
signalwire.relay.event.RecordEvent.control_id: Rust accessor for the control_id field; Python RecordEvent.control_id dataclass field.
signalwire.relay.event.RecordEvent.duration: Rust accessor for the duration field (nested record.duration fallback); Python RecordEvent.duration dataclass field.
signalwire.relay.event.RecordEvent.size: Rust accessor for the size field (nested record.size fallback); Python RecordEvent.size dataclass field.
signalwire.relay.event.RecordEvent.state: Rust accessor for the state field; Python RecordEvent.state dataclass field.
signalwire.relay.event.RecordEvent.url: Rust accessor for the url field (nested record.url fallback); Python RecordEvent.url dataclass field.
signalwire.relay.event.RelayEvent.call_id: Rust accessor for the call_id event field; Python exposes it as the RelayEvent.call_id dataclass field (not recorded by the surface enumerator, which skips dataclass fields).
signalwire.relay.event.RelayEvent.call_state: Rust accessor for the call_state event field; Python CallStateEvent.call_state dataclass field.
signalwire.relay.event.RelayEvent.class_name: Rust accessor returning the typed-event class name a payload dispatches to (mirrors Python type(parse_event(payload)).__name__ over the EVENT_CLASS_MAP dispatch table).
signalwire.relay.event.RelayEvent.direction: Rust accessor for the direction event field; Python CallStateEvent.direction dataclass field.
signalwire.relay.message.Message.body: Rust ships typed accessors on Message (body, context, direction, dispatch_event, from_number, …) where Python exposes the same data via attribute access. Python's RelayClient.send_message wraps Message construction.
signalwire.relay.message.Message.context: Rust ships typed accessors on Message (body, context, direction, dispatch_event, from_number, …) where Python exposes the same data via attribute access. Python's RelayClient.send_message wraps Message construction.
signalwire.relay.message.Message.direction: Rust ships typed accessors on Message (body, context, direction, dispatch_event, from_number, …) where Python exposes the same data via attribute access. Python's RelayClient.send_message wraps Message construction.
signalwire.relay.message.Message.dispatch_event: Rust ships typed accessors on Message (body, context, direction, dispatch_event, from_number, …) where Python exposes the same data via attribute access. Python's RelayClient.send_message wraps Message construction.
signalwire.relay.message.Message.from_number: Rust ships typed accessors on Message (body, context, direction, dispatch_event, from_number, …) where Python exposes the same data via attribute access. Python's RelayClient.send_message wraps Message construction.
signalwire.relay.message.Message.media: Rust ships typed accessors on Message (body, context, direction, dispatch_event, from_number, …) where Python exposes the same data via attribute access. Python's RelayClient.send_message wraps Message construction.
signalwire.relay.message.Message.message_id: Rust ships typed accessors on Message (body, context, direction, dispatch_event, from_number, …) where Python exposes the same data via attribute access. Python's RelayClient.send_message wraps Message construction.
signalwire.relay.message.Message.message_state: Typed Tier-3 accessor returning the delivery state as an Option<MessageState> enum (queued/initiated/sent/delivered/undelivered/failed/received, #[non_exhaustive] with Other for unknown server values), exposed ALONGSIDE the string state() for parity — when set, message_state().unwrap().as_str() == state().unwrap(). Floor-not-ceiling typed view over Python's bare-string state. Additive; no Python equivalent.
signalwire.relay.message.Message.on_completed: Rust ships typed accessors on Message (body, context, direction, dispatch_event, from_number, …) where Python exposes the same data via attribute access. Python's RelayClient.send_message wraps Message construction.
signalwire.relay.message.Message.reason: Rust ships typed accessors on Message (body, context, direction, dispatch_event, from_number, …) where Python exposes the same data via attribute access. Python's RelayClient.send_message wraps Message construction.
signalwire.relay.message.Message.resolve: Rust ships typed accessors on Message (body, context, direction, dispatch_event, from_number, …) where Python exposes the same data via attribute access. Python's RelayClient.send_message wraps Message construction.
signalwire.relay.message.Message.state: Rust ships typed accessors on Message (body, context, direction, dispatch_event, from_number, …) where Python exposes the same data via attribute access. Python's RelayClient.send_message wraps Message construction.
signalwire.relay.message.Message.tags: Rust ships typed accessors on Message (body, context, direction, dispatch_event, from_number, …) where Python exposes the same data via attribute access. Python's RelayClient.send_message wraps Message construction.
signalwire.relay.message.Message.to_number: Rust ships typed accessors on Message (body, context, direction, dispatch_event, from_number, …) where Python exposes the same data via attribute access. Python's RelayClient.send_message wraps Message construction.
signalwire.relay.state_enums.CallState: Typed call-lifecycle state (created/ringing/answered/ending/ended), #[non_exhaustive] + Other(String) for unknown server values. Terminal = ended. See section preamble.
signalwire.relay.state_enums.CallState.as_str: Canonical wire string for the state (the captured raw string for Other), so CallState::from_str(s).as_str() == s. See section preamble.
signalwire.relay.state_enums.CallState.from_str: Infallible parse of a wire string to CallState (unknown → Other); also exposed via impl FromStr. See section preamble.
signalwire.relay.state_enums.CallState.is_terminal: true iff terminal (ended); delegates to relay::constants::is_call_terminal. See section preamble.
signalwire.relay.state_enums.DialState: Typed dial-outcome state (dialing/answered/failed), #[non_exhaustive] + Other(String). Terminal = answered or failed. Distinct from CallState. See section preamble.
signalwire.relay.state_enums.DialState.as_str: Canonical wire string for the dial state (raw for Other). See section preamble.
signalwire.relay.state_enums.DialState.from_str: Infallible parse to DialState (unknown → Other); also via impl FromStr. See section preamble.
signalwire.relay.state_enums.DialState.is_terminal: true iff terminal (answered or failed). See section preamble.
signalwire.relay.state_enums.MessageState: Typed message-delivery state (queued/initiated/sent/delivered/undelivered/failed/received), #[non_exhaustive] + Other(String). Terminal = delivered/undelivered/failed. Distinct from DialState. See section preamble.
signalwire.relay.state_enums.MessageState.as_str: Canonical wire string for the delivery state (raw for Other). See section preamble.
signalwire.relay.state_enums.MessageState.from_str: Infallible parse to MessageState (unknown → Other); also via impl FromStr. See section preamble.
signalwire.relay.state_enums.MessageState.is_terminal: true iff terminal (delivered/undelivered/failed); delegates to relay::constants::is_message_terminal. See section preamble.
signalwire.rest._base.CrudResource.init: Rust CrudResource is a base struct with explicit accessors. Python's _base.CrudResource is internal.
signalwire.rest._base.CrudResource.base_path: Rust CrudResource is a base struct with explicit accessors. Python's _base.CrudResource is internal.
signalwire.rest._base.CrudResource.client: Rust CrudResource is a base struct with explicit accessors. Python's _base.CrudResource is internal.
signalwire.rest._base.CrudResource.create_with_options: create with a per-request RequestOptions override; Python's CrudResource.create(..., request_options=). Rust method-name overload (sibling of create).
signalwire.rest._base.CrudResource.delete_with_options: delete with a per-request RequestOptions override; Python's CrudResource.delete(..., request_options=). Rust method-name overload (sibling of delete).
signalwire.rest._base.CrudResource.get_with_options: get with a per-request RequestOptions override; Python's CrudResource.get(..., request_options=). Rust method-name overload (sibling of get).
signalwire.rest._base.CrudResource.list_with_options: list with a per-request RequestOptions override; Python's CrudResource.list(..., request_options=). Rust threads the per-request override through a sibling method (no default/keyword args) — the plain list keeps the client-default RequestOptions. Same method-name-overload idiom as HttpClient.get_with_options.
signalwire.rest._base.CrudResource.paginate_with_options: paginate with a per-request RequestOptions override forwarded to every page GET; Python's CrudResource.paginate(..., request_options=). Rust method-name overload (sibling of paginate).
signalwire.rest._base.CrudResource.path: Rust CrudResource exposes the base's collection+item URL composer path(parts); Python composes item paths inline per method. Rust base-helper idiom, same shape as the BaseResource/ReadResource path helpers. Surfaced when the port consolidated to a single CrudResource.
signalwire.rest._base.CrudResource.update_with_options: update with a per-request RequestOptions override; Python's CrudResource.update(..., request_options=). Rust method-name overload (sibling of update).
signalwire.rest._base.HttpClient.delete_with_options: DELETE with a per-request RequestOptions override; Python's HttpClient.delete(..., request_options=). Rust method-name overload.
signalwire.rest._base.HttpClient.get_with_options: GET with a per-request RequestOptions override (shallow-merged over the client default); Python's HttpClient.get(..., request_options=) is the same operation. Rust overloads via a distinct method name (no default/keyword args).
signalwire.rest._base.HttpClient.patch_with_options: PATCH with a per-request RequestOptions override; Python's HttpClient.patch(..., request_options=). Rust method-name overload.
signalwire.rest._base.HttpClient.post_with_options: POST with a per-request RequestOptions override; Python's HttpClient.post(..., request_options=). Rust method-name overload.
signalwire.rest._base.HttpClient.put_with_options: PUT with a per-request RequestOptions override; Python's HttpClient.put(..., request_options=). Rust method-name overload.
signalwire.rest._base.HttpClient.request_options: reads the client-default RequestOptions stored on the HttpClient; Python reads the private _request_options attribute directly. Rust accessor for the same stored default.
signalwire.rest._base.HttpClient.with_options: HttpClient constructor taking an explicit client-default RequestOptions; Python passes request_options= to HttpClient.__init__. Rust splits it into a named constructor (the base new has no options arg to preserve callers).
signalwire.rest._base.SignalWireRestError.headers: §6.6 error-observability. Mirrors the reference python SignalWireRestError.headers attribute (the response header map), exposed in Rust as a headers() -> Option<&HashMap<String,String>> accessor. Client-side only, no wire change — the typed equivalent of the reference attribute.
signalwire.rest._base.SignalWireRestError.is_transport: rust-idiom discriminator accessor (plan 1.3b) — reads whether this error is the transport-failure variant (status_code() 0, equivalent to the reference's SignalWireRestTransportError / status_code=None) vs an HTTP-status error. Python expresses the same distinction via isinstance(err, SignalWireRestTransportError); Rust folds both into one struct so needs an explicit reader. No reference counterpart under this name.
signalwire.rest._base.SignalWireRestError.request_id: §6.6 error-observability. Mirrors the reference python SignalWireRestError.request_id attribute (platform request id from x-request-id / x-signalwire-request-id / request-id / x-amzn-requestid), exposed in Rust as a request_id() -> Option<&str> accessor. Client-side only, no wire change. The surface enumerator keys the Rust accessor here; it is the typed equivalent of the reference attribute.
signalwire.rest._base.SignalWireRestError.transport: rust-error-cause-wrap constructor (plan 1.3b) — Rust folds the reference's SignalWireRestTransportError subclass into the SAME SignalWireRestError struct via an is_transport() discriminator (status_code() 0 == the reference's status_code=None); this associated function is the port's spelling of SignalWireRestTransportError.init (projected there via SURFACE_PROJECTIONS in enumerate_surface.py — see PORT_SIGNATURE_OMISSIONS.md for the extra cause arg). Rust-only associated-function name, no reference counterpart under this name.
signalwire.rest._base.SignalWireRestError.with_headers: §6.6 error-observability idiom. The reference python takes headers as an __init__ param and computes .headers/.request_id at construction; Rust mirrors .headers()/.request_id() (both present, matched) but attaches the response headers via a chained with_headers(map) -> Self builder instead of a constructor arg (the error is built by new(...) on the hot path and headers are only known after the response is read). Wire-neutral, client-side only — no reference counterpart to map to, so it is a genuine PORT_ADDITION.
signalwire.rest._request_options.EffectiveOptions: Rust resolved-form type — every RequestOptions field concretized (per-request over client-default over built-in). Python folds this into a PRIVATE _EffectiveOptions; Rust's retry loop lives in a different module (rest::http_client) than the type (rest::request_options), so the resolved form is public. Functional scaffold, not new capability.
signalwire.rest._request_options.EffectiveOptions.backoff_delay: computes the exponential backoff delay for an attempt (retry_backoff * 2**(attempt-1)); Python inlines the same expression in the retry loop. Rust helper for the same math.
signalwire.rest._request_options.EffectiveOptions.is_aborted: reads whether the resolved abort_signal is currently set (checked before each attempt); Python inlines opts.abort_signal.is_set(). Rust accessor for the same check.
signalwire.rest._request_options.RequestOptions.init: Rust struct constructor (RequestOptions::new() → an all-unset options object); Python's dataclass provides the same zero-arg default construction. Enumerator emits it as __init__; the reference records only merge on the dataclass.
signalwire.rest._request_options.default_retry_on_status: returns the built-in retryable-status set {429,500,502,503,504}; Python expresses it as the module-level constant _DEFAULT_RETRY_ON_STATUS. Rust helper form of the same default (a Rust const cannot hold a BTreeSet, so it is a fn).
signalwire.rest.client.RestClient.addresses: Rust ships every REST namespace as a method on RestClient (calling, fabric, phone_numbers, …) — these methods are required by users to access the namespaces. Python users access namespaces via attribute access on RestClient. The data and behaviour are equivalent.
signalwire.rest.client.RestClient.base_url: Rust ships every REST namespace as a method on RestClient (calling, fabric, phone_numbers, …) — these methods are required by users to access the namespaces. Python users access namespaces via attribute access on RestClient. The data and behaviour are equivalent.
signalwire.rest.client.RestClient.calling: Rust ships every REST namespace as a method on RestClient (calling, fabric, phone_numbers, …) — these methods are required by users to access the namespaces. Python users access namespaces via attribute access on RestClient. The data and behaviour are equivalent.
signalwire.rest.client.RestClient.chat: Rust ships every REST namespace as a method on RestClient (calling, fabric, phone_numbers, …) — these methods are required by users to access the namespaces. Python users access namespaces via attribute access on RestClient. The data and behaviour are equivalent.
signalwire.rest.client.RestClient.datasphere: Rust ships every REST namespace as a method on RestClient (calling, fabric, phone_numbers, …) — these methods are required by users to access the namespaces. Python users access namespaces via attribute access on RestClient. The data and behaviour are equivalent.
signalwire.rest.client.RestClient.fabric: Rust ships every REST namespace as a method on RestClient (calling, fabric, phone_numbers, …) — these methods are required by users to access the namespaces. Python users access namespaces via attribute access on RestClient. The data and behaviour are equivalent.
signalwire.rest.client.RestClient.from_env: Rust ships every REST namespace as a method on RestClient (calling, fabric, phone_numbers, …) — these methods are required by users to access the namespaces. Python users access namespaces via attribute access on RestClient. The data and behaviour are equivalent.
signalwire.rest.client.RestClient.http: Rust ships every REST namespace as a method on RestClient (calling, fabric, phone_numbers, …) — these methods are required by users to access the namespaces. Python users access namespaces via attribute access on RestClient. The data and behaviour are equivalent.
signalwire.rest.client.RestClient.imported_numbers: Rust ships every REST namespace as a method on RestClient (calling, fabric, phone_numbers, …) — these methods are required by users to access the namespaces. Python users access namespaces via attribute access on RestClient. The data and behaviour are equivalent.
signalwire.rest.client.RestClient.logs: Rust ships every REST namespace as a method on RestClient (calling, fabric, phone_numbers, …) — these methods are required by users to access the namespaces. Python users access namespaces via attribute access on RestClient. The data and behaviour are equivalent.
signalwire.rest.client.RestClient.lookup: Rust ships every REST namespace as a method on RestClient (calling, fabric, phone_numbers, …) — these methods are required by users to access the namespaces. Python users access namespaces via attribute access on RestClient. The data and behaviour are equivalent.
signalwire.rest.client.RestClient.messages: Rust ships every REST namespace as a method on RestClient (calling, fabric, phone_numbers, …) — these methods are required by users to access the namespaces. Python users access namespaces via attribute access on RestClient. The data and behaviour are equivalent.
signalwire.rest.client.RestClient.mfa: Rust ships every REST namespace as a method on RestClient (calling, fabric, phone_numbers, …) — these methods are required by users to access the namespaces. Python users access namespaces via attribute access on RestClient. The data and behaviour are equivalent.
signalwire.rest.client.RestClient.number_groups: Rust ships every REST namespace as a method on RestClient (calling, fabric, phone_numbers, …) — these methods are required by users to access the namespaces. Python users access namespaces via attribute access on RestClient. The data and behaviour are equivalent.
signalwire.rest.client.RestClient.phone_numbers: Rust ships every REST namespace as a method on RestClient (calling, fabric, phone_numbers, …) — these methods are required by users to access the namespaces. Python users access namespaces via attribute access on RestClient. The data and behaviour are equivalent.
signalwire.rest.client.RestClient.project: Rust ships every REST namespace as a method on RestClient (calling, fabric, phone_numbers, …) — these methods are required by users to access the namespaces. Python users access namespaces via attribute access on RestClient. The data and behaviour are equivalent.
signalwire.rest.client.RestClient.project_id: Rust ships every REST namespace as a method on RestClient (calling, fabric, phone_numbers, …) — these methods are required by users to access the namespaces. Python users access namespaces via attribute access on RestClient. The data and behaviour are equivalent.
signalwire.rest.client.RestClient.projects: Rust ships every REST namespace as a method on RestClient (calling, fabric, phone_numbers, …) — these methods are required by users to access the namespaces. Python users access namespaces via attribute access on RestClient. The data and behaviour are equivalent.
signalwire.rest.client.RestClient.pubsub: Rust ships every REST namespace as a method on RestClient (calling, fabric, phone_numbers, …) — these methods are required by users to access the namespaces. Python users access namespaces via attribute access on RestClient. The data and behaviour are equivalent.
signalwire.rest.client.RestClient.queues: Rust ships every REST namespace as a method on RestClient (calling, fabric, phone_numbers, …) — these methods are required by users to access the namespaces. Python users access namespaces via attribute access on RestClient. The data and behaviour are equivalent.
signalwire.rest.client.RestClient.recordings: Rust ships every REST namespace as a method on RestClient (calling, fabric, phone_numbers, …) — these methods are required by users to access the namespaces. Python users access namespaces via attribute access on RestClient. The data and behaviour are equivalent.
signalwire.rest.client.RestClient.registry: Rust ships every REST namespace as a method on RestClient (calling, fabric, phone_numbers, …) — these methods are required by users to access the namespaces. Python users access namespaces via attribute access on RestClient. The data and behaviour are equivalent.
signalwire.rest.client.RestClient.short_codes: Rust ships every REST namespace as a method on RestClient (calling, fabric, phone_numbers, …) — these methods are required by users to access the namespaces. Python users access namespaces via attribute access on RestClient. The data and behaviour are equivalent.
signalwire.rest.client.RestClient.sip_profile: Rust ships every REST namespace as a method on RestClient (calling, fabric, phone_numbers, …) — these methods are required by users to access the namespaces. Python users access namespaces via attribute access on RestClient. The data and behaviour are equivalent.
signalwire.rest.client.RestClient.space: Rust ships every REST namespace as a method on RestClient (calling, fabric, phone_numbers, …) — these methods are required by users to access the namespaces. Python users access namespaces via attribute access on RestClient. The data and behaviour are equivalent.
signalwire.rest.client.RestClient.token: Rust ships every REST namespace as a method on RestClient (calling, fabric, phone_numbers, …) — these methods are required by users to access the namespaces. Python users access namespaces via attribute access on RestClient. The data and behaviour are equivalent.
signalwire.rest.client.RestClient.verified_callers: Rust ships every REST namespace as a method on RestClient (calling, fabric, phone_numbers, …) — these methods are required by users to access the namespaces. Python users access namespaces via attribute access on RestClient. The data and behaviour are equivalent.
signalwire.rest.client.RestClient.video: Rust ships every REST namespace as a method on RestClient (calling, fabric, phone_numbers, …) — these methods are required by users to access the namespaces. Python users access namespaces via attribute access on RestClient. The data and behaviour are equivalent.
signalwire.rest.client.RestClient.with_base_url: Rust ships every REST namespace as a method on RestClient (calling, fabric, phone_numbers, …) — these methods are required by users to access the namespaces. Python users access namespaces via attribute access on RestClient. The data and behaviour are equivalent.
signalwire.rest.client.RestClient.with_base_url_and_options: RestClient constructor taking an explicit base URL AND a client-default RequestOptions; Python passes request_options= to RestClient(...). Rust splits it into a named constructor (the base with_base_url has no options arg to preserve callers).
signalwire.rest.client.RestClient.with_http: Rust ships every REST namespace as a method on RestClient (calling, fabric, phone_numbers, …) — these methods are required by users to access the namespaces. Python users access namespaces via attribute access on RestClient. The data and behaviour are equivalent.
signalwire.rest.http_client.HttpTransport: Rust-only trait abstracting the blocking HTTP transport (ureq) so tests can inject a recording transport; Python calls requests directly.
signalwire.rest.http_client.HttpTransport.execute: method of the Rust-only HttpTransport trait.
signalwire.rest.http_client.HttpTransport.execute_with_headers: §6.6 error-observability idiom. A new default trait method on the internal HttpTransport seam returning (status, response_headers, body) so the client can surface the platform request-id on an error; the real UreqTransport overrides it, stub/mock transports inherit the header-less default. Internal transport plumbing with no reference counterpart (the reference reads headers directly off requests' response object) — a genuine PORT_ADDITION, wire-neutral.
signalwire.rest.http_client.StubTransport: Rust splits the HTTP transport into a public HttpClient with two pluggable transport types (UreqTransport for production, StubTransport for tests). Python uses requests directly.
signalwire.rest.http_client.StubTransport.init: Rust splits the HTTP transport into a public HttpClient with two pluggable transport types (UreqTransport for production, StubTransport for tests). Python uses requests directly.
signalwire.rest.http_client.StubTransport.set_response: Rust splits the HTTP transport into a public HttpClient with two pluggable transport types (UreqTransport for production, StubTransport for tests). Python uses requests directly.
signalwire.rest.http_client.UreqTransport: Rust splits the HTTP transport into a public HttpClient with two pluggable transport types (UreqTransport for production, StubTransport for tests). Python uses requests directly.
signalwire.rest.http_client.UreqTransport.init: Rust splits the HTTP transport into a public HttpClient with two pluggable transport types (UreqTransport for production, StubTransport for tests). Python uses requests directly.
signalwire.security.webhook_layer.WebhookLayer: rust_idiom: tower::Layer for axum/hyper (Python uses FastAPI dependency factory)
signalwire.security.webhook_layer.WebhookLayer.init: rust_idiom: see WebhookLayer entry
signalwire.security.webhook_layer.WebhookLayer.with_url_base: rust_idiom_builder: builder method for proxy URL base (Rust idiom, no Python equivalent)
signalwire.server.tls.bind_server: rust-transport-helper — pub(crate) HTTP/HTTPS listener bind shared by the server entry points (selects TLS via the SSL-related SWML_ env vars). Python uses uvicorn's ssl_*.
signalwire.serverless.adapter.Adapter: Rust ships a typed Adapter / RuntimeEnvironment pair for serverless mode detection and event handling. Python uses a flatter signalwire/serverless module.
signalwire.serverless.adapter.Adapter.detect: Rust ships a typed Adapter / RuntimeEnvironment pair for serverless mode detection and event handling. Python uses a flatter signalwire/serverless module.
signalwire.serverless.adapter.Adapter.handle_azure: Rust ships a typed Adapter / RuntimeEnvironment pair for serverless mode detection and event handling. Python uses a flatter signalwire/serverless module.
signalwire.serverless.adapter.Adapter.handle_cgi: Rust ships a typed Adapter / RuntimeEnvironment pair for serverless mode detection and event handling. Python uses a flatter signalwire/serverless module. This is the per-platform CGI dispatcher (Python's handle_serverless_request mode=="cgi" branch) exposed as a named method alongside handle_lambda/handle_azure/handle_gcf.
signalwire.serverless.adapter.Adapter.handle_gcf: Rust ships a typed Adapter / RuntimeEnvironment pair for serverless mode detection and event handling. Python uses a flatter signalwire/serverless module. This is the per-platform Google Cloud Function dispatcher (Python's handle_serverless_request mode=="google_cloud_function" branch) exposed as a named method alongside handle_lambda/handle_azure/handle_cgi.
signalwire.serverless.adapter.Adapter.handle_lambda: Rust ships a typed Adapter / RuntimeEnvironment pair for serverless mode detection and event handling. Python uses a flatter signalwire/serverless module.
signalwire.serverless.adapter.Adapter.serve_detect: Rust ships a typed Adapter / RuntimeEnvironment pair for serverless mode detection and event handling. Python uses a flatter signalwire/serverless module.
signalwire.serverless.adapter.Adapter.status_text: Rust ships a typed Adapter / RuntimeEnvironment pair for serverless mode detection and event handling. Python uses a flatter signalwire/serverless module.
signalwire.serverless.adapter.RequestHandler: Rust-only trait abstracting a serverless request handler; Python uses duck-typed callables.
signalwire.serverless.adapter.RequestHandler.handle_request: method of the Rust-only RequestHandler trait.
signalwire.serverless.adapter.RuntimeEnvironment: Rust ships a typed Adapter / RuntimeEnvironment pair for serverless mode detection and event handling. Python uses a flatter signalwire/serverless module.
signalwire.serverless.adapter.RuntimeEnvironment.as_str: Rust ships a typed Adapter / RuntimeEnvironment pair for serverless mode detection and event handling. Python uses a flatter signalwire/serverless module.
signalwire.skills.claude_skills.skill.ClaudeSkillsSkill.init: Each Rust skill exposes a constructor (mapped to init). Python skills also have constructors but the per-symbol enumerator may not list them under the same path.
signalwire.skills.claude_skills.skill.ClaudeSkillsSkill.get_prompt_sections: port-only: Rust's claude_skills skill overrides get_prompt_sections; the Python reference's ClaudeSkillsSkill does not declare it (relies on the SkillBase default)
signalwire.skills.custom_skills.skill.CustomSkillsSkill: Rust ships custom_skills as a registered skill. Python doesn't have it as a separate module.
signalwire.skills.custom_skills.skill.CustomSkillsSkill.init: Each Rust skill exposes a constructor (mapped to init). Python skills also have constructors but the per-symbol enumerator may not list them under the same path.
signalwire.skills.custom_skills.skill.CustomSkillsSkill.register_tools: port-only: method of the Rust-only custom_skills skill (Python has no custom_skills module)
signalwire.skills.custom_skills.skill.CustomSkillsSkill.setup: port-only: method of the Rust-only custom_skills skill (Python has no custom_skills module)
signalwire.skills.datasphere.skill.DataSphereSkill.init: Each Rust skill exposes a constructor (mapped to init). Python skills also have constructors but the per-symbol enumerator may not list them under the same path.
signalwire.skills.datasphere_serverless.skill.DataSphereServerlessSkill.init: Each Rust skill exposes a constructor (mapped to init). Python skills also have constructors but the per-symbol enumerator may not list them under the same path.
signalwire.skills.datetime.skill.DateTimeSkill.init: Each Rust skill exposes a constructor (mapped to init). Python skills also have constructors but the per-symbol enumerator may not list them under the same path.
signalwire.skills.google_maps.skill.GoogleMapsSkill.init: Each Rust skill exposes a constructor (mapped to init). Python skills also have constructors but the per-symbol enumerator may not list them under the same path.
signalwire.skills.info_gatherer.skill.InfoGathererSkill.init: Each Rust skill exposes a constructor (mapped to init). Python skills also have constructors but the per-symbol enumerator may not list them under the same path.
signalwire.skills.info_gatherer.skill.InfoGathererSkill.get_prompt_sections: port-only: Rust's info_gatherer skill overrides get_prompt_sections; the Python reference's InfoGathererSkill does not declare it (relies on the SkillBase default)
signalwire.skills.joke.skill.JokeSkill.init: Each Rust skill exposes a constructor (mapped to init). Python skills also have constructors but the per-symbol enumerator may not list them under the same path.
signalwire.skills.math.skill.MathSkill.init: Each Rust skill exposes a constructor (mapped to init). Python skills also have constructors but the per-symbol enumerator may not list them under the same path.
signalwire.skills.mcp_gateway.skill.MCPGatewaySkill: mcp_gateway CLIENT skill — canonical on porting-sdk wave/1-aplus (oracle commit f4d2154); recorded here only while PR CI's porting-sdk is main (oracle behind). Matches the reference on wave/1-aplus.
signalwire.skills.mcp_gateway.skill.MCPGatewaySkill.init: Each Rust skill exposes a constructor (mapped to init). Python skills also have constructors but the per-symbol enumerator may not list them under the same path.
signalwire.skills.native_vector_search.skill.NativeVectorSearchSkill.init: Each Rust skill exposes a constructor (mapped to init). Python skills also have constructors but the per-symbol enumerator may not list them under the same path.
signalwire.skills.registry.SkillRegistry.external_paths: external_paths returns the directories registered via add_skill_directory (mirroring Python's _external_paths attribute). get_factory returns a closure-wrapped factory (Rust replacement for Python's get_skill / get_skill_class).
signalwire.skills.registry.SkillRegistry.get_factory: external_paths returns the directories registered via add_skill_directory (mirroring Python's _external_paths attribute). get_factory returns a closure-wrapped factory (Rust replacement for Python's get_skill / get_skill_class).
signalwire.skills.skill_base.SkillParams: Rust ships SkillParams + value_to_map as typed helpers for parameter unpacking. Python uses Dict[str, Any] directly.
signalwire.skills.skill_base.SkillParams.init: Rust ships SkillParams + value_to_map as typed helpers for parameter unpacking. Python uses Dict[str, Any] directly.
signalwire.skills.skill_base.SkillParams.empty: Rust ships SkillParams + value_to_map as typed helpers for parameter unpacking. Python uses Dict[str, Any] directly.
signalwire.skills.skill_base.SkillParams.get_array: Rust ships SkillParams + value_to_map as typed helpers for parameter unpacking. Python uses Dict[str, Any] directly.
signalwire.skills.skill_base.SkillParams.get_bool: Rust ships SkillParams + value_to_map as typed helpers for parameter unpacking. Python uses Dict[str, Any] directly.
signalwire.skills.skill_base.SkillParams.get_bool_or: Rust ships SkillParams + value_to_map as typed helpers for parameter unpacking. Python uses Dict[str, Any] directly.
signalwire.skills.skill_base.SkillParams.get_f64: Rust ships SkillParams + value_to_map as typed helpers for parameter unpacking. Python uses Dict[str, Any] directly.
signalwire.skills.skill_base.SkillParams.get_i64: Rust ships SkillParams + value_to_map as typed helpers for parameter unpacking. Python uses Dict[str, Any] directly.
signalwire.skills.skill_base.SkillParams.get_object: Rust ships SkillParams + value_to_map as typed helpers for parameter unpacking. Python uses Dict[str, Any] directly.
signalwire.skills.skill_base.SkillParams.get_str: Rust ships SkillParams + value_to_map as typed helpers for parameter unpacking. Python uses Dict[str, Any] directly.
signalwire.skills.skill_base.SkillParams.get_str_or: Rust ships SkillParams + value_to_map as typed helpers for parameter unpacking. Python uses Dict[str, Any] directly.
signalwire.skills.skill_base.value_to_map: Rust ships SkillParams + value_to_map as typed helpers for parameter unpacking. Python uses Dict[str, Any] directly.
signalwire.skills.skill_name.ParseSkillNameError: rust-parse-error — FromStr::Err for SkillName ("datetime".parse::<SkillName>()); the open-set inherent from_str still returns Option for custom names. No Python equivalent.
signalwire.skills.skill_name.ParseSkillNameError.input: rust-error-accessor — returns the string that was not a built-in skill name. No Python equivalent.
signalwire.skills.skill_name.SkillName: rust_enum_idiom: typed closed set of the 17 built-in skill names; add_skill/remove_skill/has_skill keep their &str param (Python parity + custom skills) and accept this enum via as_str()/AsRef. Wire behaviour identical.
signalwire.skills.skill_name.SkillName.all: rust_enum_idiom: &'static slice of every built-in SkillName for exhaustive iteration (see SkillName).
signalwire.skills.skill_name.SkillName.as_str: rust_enum_idiom: returns the canonical snake_case wire name (see SkillName) — the exact string add_skill(&str) expects, so the enum and string paths load the identical skill.
signalwire.skills.skill_name.SkillName.from_str: rust_enum_idiom: parse a wire name back to a SkillName, None for custom/third-party names (see SkillName).
signalwire.skills.swml_transfer.skill.SWMLTransferSkill.init: Each Rust skill exposes a constructor (mapped to init). Python skills also have constructors but the per-symbol enumerator may not list them under the same path.
signalwire.skills.web_search.skill.WebSearchSkill.init: Each Rust skill exposes a constructor (mapped to init). Python skills also have constructors but the per-symbol enumerator may not list them under the same path.
signalwire.skills.wikipedia_search.skill.WikipediaSearchSkill.init: Each Rust skill exposes a constructor (mapped to init). Python skills also have constructors but the per-symbol enumerator may not list them under the same path.
signalwire.swaig.function_result.KeysArg: rust_union_idiom: the Union[str, List[str]] argument wrapper behind FunctionResult.remove_global_data / remove_metadata (Python's keys: Union[str, List[str]]). KeysArg is One(String) (a single key) OR Many(Vec<String>) (a key list); a single impl Into<KeysArg> param accepts both "plan" and vec!["plan","chips"] with no overloads. Restores Python's pass-through emission: the One arm emits the BARE KEY STRING ({"unset_global_data":"plan"}), the Many arm emits the ARRAY ({"unset_global_data":["plan","chips"]}) — byte-identical to the reference per arm (the prior bare-Vec<&str> signature could only emit the array, wrongly wrapping a single key; the cross-port emission differ caught it). No Python equivalent symbol (Python uses an untagged union on a bare str/list); this is the Rust typed-form that models it.
signalwire.swaig.function_result.KeysArg.into_value: rust_union_idiom: the JSON wire value this arg resolves to — a bare string for the One arm, an array for the Many arm — matching Python's verbatim pass-through of its Union[str, List[str]] value (see KeysArg).
signalwire.swaig.media_enums.Codec: rust_enum_idiom: typed {PCMU,PCMA} for FunctionResult.tap(codec) — mirrors Python's valid_codecs = ["PCMU","PCMA"] validation. tap keeps &str, accepts this via as_str()/AsRef. Wire output identical (upper-case strings).
signalwire.swaig.media_enums.Codec.all: rust_enum_idiom: &'static slice of every Codec for exhaustive iteration (see Codec).
signalwire.swaig.media_enums.Codec.as_str: rust_enum_idiom: canonical upper-case wire string for the codec (see Codec) — the exact string tap(&str) expects.
signalwire.swaig.media_enums.Codec.from_str: rust_enum_idiom: parse a wire string to a Codec (case-sensitive, mirroring the reference's literal list), None otherwise (see Codec).
signalwire.swaig.media_enums.MediaArg: rust_enum_idiom: the typed-or-raw parameter wrapper behind record_call(format,direction) / tap(direction,codec). MediaArg<E> is Typed(E) (the closed-set enum) OR Raw(String) (a raw wire string carried verbatim, validated in the method body exactly as Python validates its str arg). Lets a single impl Into<MediaArg<E>> param accept both RecordFormat::Wav and "wav" with no overloads and byte-identical wire output. No Python equivalent (Python's param is a bare str); this is the typed-form the wave-1 oracle's enum<…> contract requires while keeping the str path for forward-compat.
signalwire.swaig.media_enums.MediaArg.wire: rust_enum_idiom: the canonical wire string this arg resolves to — as_str() for the Typed arm, the string verbatim for the Raw arm. The method body validates this against the closed set before emitting, so both call styles yield identical SWML (see MediaArg).
signalwire.swaig.media_enums.ParseMediaEnumError: rust-parse-error — FromStr::Err for RecordFormat/RecordDirection/TapDirection/Codec; the typed analogue of Python's ValueError on the media-action closed sets.
signalwire.swaig.media_enums.ParseMediaEnumError.input: rust-error-accessor — returns the string that failed to parse. Python's ValueError carries only a message.
signalwire.swaig.media_enums.RecordDirection: rust_enum_idiom: typed {speak,listen,both} for FunctionResult.record_call(direction) — mirrors Python's direction in ["speak","listen","both"] validation. Distinct from TapDirection (uses hear, not listen). record_call keeps &str. Wire output identical.
signalwire.swaig.media_enums.RecordDirection.all: rust_enum_idiom: &'static slice of every RecordDirection for exhaustive iteration (see RecordDirection).
signalwire.swaig.media_enums.RecordDirection.as_str: rust_enum_idiom: canonical wire string for the direction (see RecordDirection) — the exact string record_call(&str) expects.
signalwire.swaig.media_enums.RecordDirection.from_str: rust_enum_idiom: parse a wire string to a RecordDirection, None for anything the reference would reject — including hear, which is valid only for tap (see RecordDirection).
signalwire.swaig.media_enums.RecordFormat: rust_enum_idiom: typed {wav,mp3,mp4} for FunctionResult.record_call(format) — mirrors Python's format in ["wav","mp3","mp4"] validation. record_call accepts this directly via impl Into<MediaArg<RecordFormat>> (and the raw &str still works). Wire output identical.
signalwire.swaig.media_enums.RecordFormat.all: rust_enum_idiom: &'static slice of every RecordFormat for exhaustive iteration (see RecordFormat).
signalwire.swaig.media_enums.RecordFormat.as_str: rust_enum_idiom: canonical wire string for the format (see RecordFormat) — the exact string record_call(&str) expects.
signalwire.swaig.media_enums.RecordFormat.from_str: rust_enum_idiom: parse a wire string to a RecordFormat, None for anything the reference would reject (see RecordFormat).
signalwire.swaig.media_enums.TapDirection: rust_enum_idiom: typed {speak,hear,both} for FunctionResult.tap(direction) — mirrors Python's valid_directions = ["speak","hear","both"] validation. Distinct from RecordDirection (uses listen, not hear). tap keeps &str. Wire output identical.
signalwire.swaig.media_enums.TapDirection.all: rust_enum_idiom: &'static slice of every TapDirection for exhaustive iteration (see TapDirection).
signalwire.swaig.media_enums.TapDirection.as_str: rust_enum_idiom: canonical wire string for the direction (see TapDirection) — the exact string tap(&str) expects.
signalwire.swaig.media_enums.TapDirection.from_str: rust_enum_idiom: parse a wire string to a TapDirection, None for anything the reference would reject — including listen, which is valid only for record_call (see TapDirection).
signalwire.swaig.params_builder.ParamKind: rust-builder-idiom: JSON-Schema primitive-type enum ({string,number,integer,boolean,array,object}) used by the typed param builder; renders the literal "type" value. No Python equivalent (Python writes the type string inline).
signalwire.swaig.params_builder.ParamKind.as_str: rust-builder-idiom: canonical JSON-Schema "type" string for the kind (e.g. "integer") — what lands in the schema, byte-identical to the hand-written literal.
signalwire.swaig.params_builder.ParamsBuilder: rust-builder-idiom: fluent typed builder for a SWAIG tool's parameter schema; produces the SAME untyped serde_json::Value define_tool already accepts. Additive convenience, untyped path unchanged.
signalwire.swaig.params_builder.ParamsBuilder.init: rust-builder-idiom: ParamsBuilder::new() — start an empty parameter schema (enumerator maps Rust new → __init__).
signalwire.swaig.params_builder.ParamsBuilder.array: rust-builder-idiom: add an array property with a ParamKind element type, emitting {"type":"array","items":{"type":…}} — byte-identical to the hand-written form.
signalwire.swaig.params_builder.ParamsBuilder.boolean: rust-builder-idiom: add a boolean property with description — byte-identical to the hand-written {"type":"boolean","description":…}.
signalwire.swaig.params_builder.ParamsBuilder.build: rust-builder-idiom: render the properties object the unchanged define_tool(parameters) accepts; byte-identical to the hand-written json!({…}) properties blob.
signalwire.swaig.params_builder.ParamsBuilder.build_schema: rust-builder-idiom: render the full {"type":"object","properties":{…},"required":[…]} schema (Python's _ensure_parameter_structure output); byte-identical to the hand-written full schema used with register_swaig_function / DataMap.
signalwire.swaig.params_builder.ParamsBuilder.enum_of: rust-builder-idiom: add a closed-set (enum) property from any impl AsRef<str> iterator (the Tier-1 media enums plug in via all()), emitting {"type":"string","enum":[…]} — byte-identical to the hand-written enum schema.
signalwire.swaig.params_builder.ParamsBuilder.integer: rust-builder-idiom: add an integer property with description — byte-identical to the hand-written {"type":"integer","description":…}.
signalwire.swaig.params_builder.ParamsBuilder.number: rust-builder-idiom: add a number (float) property with description — byte-identical to the hand-written {"type":"number","description":…}.
signalwire.swaig.params_builder.ParamsBuilder.object: rust-builder-idiom: add a nested object property whose shape is another ParamsBuilder, emitting {"type":"object","properties":{…}} (plus nested required) — byte-identical to the hand-written nested schema.
signalwire.swaig.params_builder.ParamsBuilder.property: rust-builder-idiom: add a fully-customised property built via PropertyBuilder (escape hatch for default/format/per-property required); inserts its rendered object verbatim.
signalwire.swaig.params_builder.ParamsBuilder.required: rust-builder-idiom: declare the top-level required-parameter list (JSON-Schema sibling of properties, == Python's required=[…] arg); surfaces in build_schema()'s "required":[…].
signalwire.swaig.params_builder.ParamsBuilder.required_names: rust-builder-idiom: read back the declared top-level required-parameter names (the list required(…) set); consumed by type_inference::infer_schema to fill the required element of its schema tuple. No Python equivalent (Python reads required-ness off the reflected handler signature, not a builder).
signalwire.swaig.params_builder.ParamsBuilder.string: rust-builder-idiom: add a string property with description — byte-identical to the hand-written {"type":"string","description":…}.
signalwire.swaig.params_builder.PropertyBuilder: rust-builder-idiom: per-property typed builder for options the one-line ParamsBuilder helpers don't cover (default/format/per-property required/nesting); renders the same {"type":…,"description":…,…} object as hand-written.
signalwire.swaig.params_builder.PropertyBuilder.init: rust-builder-idiom: PropertyBuilder::new(kind, description) — start a property of the given ParamKind with an LLM-facing description (enumerator maps new → __init__).
signalwire.swaig.params_builder.PropertyBuilder.build: rust-builder-idiom: finish the property, yielding its rendered schema object; byte-identical to the hand-written property object.
signalwire.swaig.params_builder.PropertyBuilder.default: rust-builder-idiom: attach a "default" value to the property — byte-identical to the hand-written "default":….
signalwire.swaig.params_builder.PropertyBuilder.enum_values: rust-builder-idiom: constrain the property to a closed set ("enum":[…]) from any impl AsRef<str> iterator — how the Tier-1 media enums integrate.
signalwire.swaig.params_builder.PropertyBuilder.extra: rust-builder-idiom: escape hatch to insert an arbitrary extra schema key (e.g. "minimum", "pattern") without a dedicated helper.
signalwire.swaig.params_builder.PropertyBuilder.format: rust-builder-idiom: attach a JSON-Schema "format" hint ("date"/"email"/…); the format vocabulary is open so this stays a &str.
signalwire.swaig.params_builder.PropertyBuilder.items: rust-builder-idiom: set the array element schema, emitting "items":{"type":…} — byte-identical to the hand-written array items.
signalwire.swaig.params_builder.PropertyBuilder.properties: rust-builder-idiom: set the nested properties (and nested required) for an object property from another ParamsBuilder — byte-identical to the hand-written nested object schema.
signalwire.swaig.params_builder.PropertyBuilder.required: rust-builder-idiom: per-property "required": true flag (the style some skills use, e.g. the datasphere skill); distinct from ParamsBuilder.required's top-level array.
signalwire.swml.schema.get_verb: Rust ships free functions for schema introspection. Python provides equivalents via signalwire.utils.schema_utils.SchemaUtils (which is in PORT_OMISSIONS.md).
signalwire.swml.schema.get_verb_names: Rust ships free functions for schema introspection. Python provides equivalents via signalwire.utils.schema_utils.SchemaUtils (which is in PORT_OMISSIONS.md).
signalwire.swml.schema.is_valid_verb: Rust ships free functions for schema introspection. Python provides equivalents via signalwire.utils.schema_utils.SchemaUtils (which is in PORT_OMISSIONS.md).
signalwire.swml.schema.verb_count: Rust ships free functions for schema introspection. Python provides equivalents via signalwire.utils.schema_utils.SchemaUtils (which is in PORT_OMISSIONS.md).
signalwire.utils.schema_utils.SchemaUtils.generate_method_body: Python-source codegen helper; canonical Python signatures filter this method out (Python-only output shape)
signalwire.utils.schema_utils.SchemaUtils.generate_method_signature: Python-source codegen helper; canonical Python signatures filter this method out (Python-only output shape)
signalwire.utils.url_validator._set_resolver: port-only test helper: Rust exposes a _set_resolver function so the audit harness can inject DNS-resolver mocks for url_validator tests; Python's equivalent test path patches the resolver via unittest.mock.patch.